109 files changed, 13905 insertions, 4352 deletions
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index cc8093c15cf5..4d2566a7d168 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -287,6 +287,13 @@ Who:	Glauber Costa <gcosta@redhat.com>
 ---------------------------
+What:   remove HID compat support
+When:   2.6.29
+Why:    needed only as a temporary solution until distros fix themselves up
+Who:    Jiri Slaby <jirislaby@gmail.com>
+---------------------------
 What:   /sys/o2cb symlink
 When:   January 2010
 Why:    /sys/fs/o2cb is the proper location for this information - /sys/o2cb
diff --git a/Documentation/filesystems/ocfs2.txt b/Documentation/filesystems/ocfs2.txt
index c318a8bbb1ef..4340cc825796 100644
--- a/Documentation/filesystems/ocfs2.txt
+++ b/Documentation/filesystems/ocfs2.txt
@@ -76,3 +76,9 @@ localalloc=8(*)		Allows custom localalloc size in MB. If the value is too
                        large, the fs will silently revert it to the default.
                        Localalloc is not enabled for local mounts.
 localflocks             This disables cluster aware flock.
+inode64                 Indicates that Ocfs2 is allowed to create inodes at
+                        any location in the filesystem, including those which
+                        will result in inode numbers occupying more than 32
+                        bits of significance.
+user_xattr      (*)     Enables Extended User Attributes.
+nouser_xattr            Disables Extended User Attributes.
diff --git a/Documentation/i2c/busses/i2c-viapro b/Documentation/i2c/busses/i2c-viapro
index 1405fb69984c..22efedf60c87 100644
--- a/Documentation/i2c/busses/i2c-viapro
+++ b/Documentation/i2c/busses/i2c-viapro
@@ -16,6 +16,9 @@ Supported adapters:
  * VIA Technologies, Inc. CX700
    Datasheet: available on request and under NDA from VIA
+  * VIA Technologies, Inc. VX800/VX820
+    Datasheet: available on http://linux.via.com.tw
 Authors:
        Kyösti Mälkki <kmalkki@cc.hut.fi>,
        Mark D. Studebaker <mdsxyz123@yahoo.com>,
@@ -49,6 +52,7 @@ Your lspci -n listing must show one of these :
 device 1106:3372   (VT8237S)
 device 1106:3287   (VT8251)
 device 1106:8324   (CX700)
+ device 1106:8353   (VX800/VX820)
 If none of these show up, you should look in the BIOS for settings like
 enable ACPI / SMBus or even USB.
@@ -57,5 +61,5 @@ Except for the oldest chips (VT82C596A/B, VT82C686A and most probably
 VT8231), this driver supports I2C block transactions. Such transactions
 are mainly useful to read from and write to EEPROMs.
-The CX700 additionally appears to support SMBus PEC, although this driver
+The CX700/VX800/VX820 additionally appears to support SMBus PEC, although
-doesn't implement it yet.
+this driver doesn't implement it yet.
diff --git a/Documentation/i2c/dev-interface b/Documentation/i2c/dev-interface
index 9dd79123ddd9..3e742ba25536 100644
--- a/Documentation/i2c/dev-interface
+++ b/Documentation/i2c/dev-interface
@@ -4,6 +4,10 @@ the /dev interface. You need to load module i2c-dev for this.
 Each registered i2c adapter gets a number, counting from 0. You can
 examine /sys/class/i2c-dev/ to see what number corresponds to which adapter.
+Alternatively, you can run "i2cdetect -l" to obtain a formated list of all
+i2c adapters present on your system at a given time. i2cdetect is part of
+the i2c-tools package.
 I2C device files are character device files with major device number 89
 and a minor device number corresponding to the number assigned as 
 explained above. They should be called "i2c-%d" (i2c-0, i2c-1, ..., 
@@ -17,30 +21,34 @@ So let's say you want to access an i2c adapter from a C program. The
 first thing to do is "#include <linux/i2c-dev.h>". Please note that
 there are two files named "i2c-dev.h" out there, one is distributed
 with the Linux kernel and is meant to be included from kernel
-driver code, the other one is distributed with lm_sensors and is
+driver code, the other one is distributed with i2c-tools and is
 meant to be included from user-space programs. You obviously want
 the second one here.
 Now, you have to decide which adapter you want to access. You should
-inspect /sys/class/i2c-dev/ to decide this. Adapter numbers are assigned
+inspect /sys/class/i2c-dev/ or run "i2cdetect -l" to decide this.
-somewhat dynamically, so you can not even assume /dev/i2c-0 is the
+Adapter numbers are assigned somewhat dynamically, so you can not
-first adapter.
+assume much about them. They can even change from one boot to the next.
 Next thing, open the device file, as follows:
  int file;
  int adapter_nr = 2; /* probably dynamically determined */
  char filename[20];
  
-  sprintf(filename,"/dev/i2c-%d",adapter_nr);
+  snprintf(filename, 19, "/dev/i2c-%d", adapter_nr);
-  if ((file = open(filename,O_RDWR)) < 0) {
+  file = open(filename, O_RDWR);
+  if (file < 0) {
    /* ERROR HANDLING; you can check errno to see what went wrong */
    exit(1);
  }
 When you have opened the device, you must specify with what device
 address you want to communicate:
  int addr = 0x40; /* The I2C address */
-  if (ioctl(file,I2C_SLAVE,addr) < 0) {
+  if (ioctl(file, I2C_SLAVE, addr) < 0) {
    /* ERROR HANDLING; you can check errno to see what went wrong */
    exit(1);
  }
@@ -48,31 +56,41 @@ address you want to communicate:
 Well, you are all set up now. You can now use SMBus commands or plain
 I2C to communicate with your device. SMBus commands are preferred if
 the device supports them. Both are illustrated below.
  __u8 register = 0x10; /* Device register to access */
  __s32 res;
  char buf[10];
  /* Using SMBus commands */
-  res = i2c_smbus_read_word_data(file,register);
+  res = i2c_smbus_read_word_data(file, register);
  if (res < 0) {
    /* ERROR HANDLING: i2c transaction failed */
  } else {
    /* res contains the read word */
  }
  /* Using I2C Write, equivalent of 
-           i2c_smbus_write_word_data(file,register,0x6543) */
+     i2c_smbus_write_word_data(file, register, 0x6543) */
  buf[0] = register;
  buf[1] = 0x43;
  buf[2] = 0x65;
-  if ( write(file,buf,3) != 3) {
+  if (write(file, buf, 3) ! =3) {
    /* ERROR HANDLING: i2c transaction failed */
  }
  /* Using I2C Read, equivalent of i2c_smbus_read_byte(file) */
-  if (read(file,buf,1) != 1) {
+  if (read(file, buf, 1) != 1) {
    /* ERROR HANDLING: i2c transaction failed */
  } else {
    /* buf[0] contains the read byte */
  }
+Note that only a subset of the I2C and SMBus protocols can be achieved by
+the means of read() and write() calls. In particular, so-called combined
+transactions (mixing read and write messages in the same transaction)
+aren't supported. For this reason, this interface is almost never used by
+user-space programs.
 IMPORTANT: because of the use of inline functions, you *have* to use
 '-O' or some variation when you compile your program!
@@ -80,31 +98,29 @@ IMPORTANT: because of the use of inline functions, you *have* to use
 Full interface description
 ==========================
-The following IOCTLs are defined and fully supported 
+The following IOCTLs are defined:
-(see also i2c-dev.h):
-ioctl(file,I2C_SLAVE,long addr)
+ioctl(file, I2C_SLAVE, long addr)
  Change slave address. The address is passed in the 7 lower bits of the
  argument (except for 10 bit addresses, passed in the 10 lower bits in this
  case).
-ioctl(file,I2C_TENBIT,long select)
+ioctl(file, I2C_TENBIT, long select)
  Selects ten bit addresses if select not equals 0, selects normal 7 bit
  addresses if select equals 0. Default 0.  This request is only valid
  if the adapter has I2C_FUNC_10BIT_ADDR.
-ioctl(file,I2C_PEC,long select)
+ioctl(file, I2C_PEC, long select)
  Selects SMBus PEC (packet error checking) generation and verification
  if select not equals 0, disables if select equals 0. Default 0.
  Used only for SMBus transactions.  This request only has an effect if the
  the adapter has I2C_FUNC_SMBUS_PEC; it is still safe if not, it just
  doesn't have any effect.
-ioctl(file,I2C_FUNCS,unsigned long *funcs)
+ioctl(file, I2C_FUNCS, unsigned long *funcs)
  Gets the adapter functionality and puts it in *funcs.
-ioctl(file,I2C_RDWR,struct i2c_rdwr_ioctl_data *msgset)
+ioctl(file, I2C_RDWR, struct i2c_rdwr_ioctl_data *msgset)
  Do combined read/write transaction without stop in between.
  Only valid if the adapter has I2C_FUNC_I2C.  The argument is
  a pointer to a
@@ -120,10 +136,9 @@ ioctl(file,I2C_RDWR,struct i2c_rdwr_ioctl_data *msgset)
  The slave address and whether to use ten bit address mode has to be
  set in each message, overriding the values set with the above ioctl's.
+ioctl(file, I2C_SMBUS, struct i2c_smbus_ioctl_data *args)
-Other values are NOT supported at this moment, except for I2C_SMBUS,
+  Not meant to be called  directly; instead, use the access functions
-which you should never directly call; instead, use the access functions
+  below.
-below.
 You can do plain i2c transactions by using read(2) and write(2) calls.
 You do not need to pass the address byte; instead, set it through
@@ -148,7 +163,52 @@ what happened. The 'write' transactions return 0 on success; the
 returns the number of values read. The block buffers need not be longer
 than 32 bytes.
-The above functions are all macros, that resolve to calls to the
+The above functions are all inline functions, that resolve to calls to
-i2c_smbus_access function, that on its turn calls a specific ioctl
+the i2c_smbus_access function, that on its turn calls a specific ioctl
 with the data in a specific format. Read the source code if you
 want to know what happens behind the screens.
+Implementation details
+======================
+For the interested, here's the code flow which happens inside the kernel
+when you use the /dev interface to I2C:
+1* Your program opens /dev/i2c-N and calls ioctl() on it, as described in
+section "C example" above.
+2* These open() and ioctl() calls are handled by the i2c-dev kernel
+driver: see i2c-dev.c:i2cdev_open() and i2c-dev.c:i2cdev_ioctl(),
+respectively. You can think of i2c-dev as a generic I2C chip driver
+that can be programmed from user-space.
+3* Some ioctl() calls are for administrative tasks and are handled by
+i2c-dev directly. Examples include I2C_SLAVE (set the address of the
+device you want to access) and I2C_PEC (enable or disable SMBus error
+checking on future transactions.)
+4* Other ioctl() calls are converted to in-kernel function calls by
+i2c-dev. Examples include I2C_FUNCS, which queries the I2C adapter
+functionality using i2c.h:i2c_get_functionality(), and I2C_SMBUS, which
+performs an SMBus transaction using i2c-core.c:i2c_smbus_xfer().
+The i2c-dev driver is responsible for checking all the parameters that
+come from user-space for validity. After this point, there is no
+difference between these calls that came from user-space through i2c-dev
+and calls that would have been performed by kernel I2C chip drivers
+directly. This means that I2C bus drivers don't need to implement
+anything special to support access from user-space.
+5* These i2c-core.c/i2c.h functions are wrappers to the actual
+implementation of your I2C bus driver. Each adapter must declare
+callback functions implementing these standard calls.
+i2c.h:i2c_get_functionality() calls i2c_adapter.algo->functionality(),
+while i2c-core.c:i2c_smbus_xfer() calls either
+adapter.algo->smbus_xfer() if it is implemented, or if not,
+i2c-core.c:i2c_smbus_xfer_emulated() which in turn calls
+i2c_adapter.algo->master_xfer().
+After your I2C bus driver has processed these requests, execution runs
+up the call chain, with almost no processing done, except by i2c-dev to
+package the returned data, if any, in suitable format for the ioctl.
diff --git a/Documentation/i2c/smbus-protocol b/Documentation/i2c/smbus-protocol
index 24bfb65da17d..9df47441f0e7 100644
--- a/Documentation/i2c/smbus-protocol
+++ b/Documentation/i2c/smbus-protocol
@@ -109,8 +109,8 @@ specified through the Comm byte.
 S Addr Wr [A] Comm [A] DataLow [A] DataHigh [A] P
-SMBus Process Call
+SMBus Process Call:  i2c_smbus_process_call()
-==================
+=============================================
 This command selects a device register (through the Comm byte), sends
 16 bits of data to it, and reads 16 bits of data in return.
diff --git a/Documentation/i2c/writing-clients b/Documentation/i2c/writing-clients
index 6b61b3a2e90b..d73ee117a8ca 100644
--- a/Documentation/i2c/writing-clients
+++ b/Documentation/i2c/writing-clients
@@ -606,6 +606,8 @@ SMBus communication
  extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
  extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
                                       u8 command, u16 value);
+  extern s32 i2c_smbus_process_call(struct i2c_client *client,
+                                    u8 command, u16 value);
  extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
                                       u8 command, u8 *values);
  extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
@@ -621,8 +623,6 @@ These ones were removed from i2c-core because they had no users, but could
 be added back later if needed:
  extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
-  extern s32 i2c_smbus_process_call(struct i2c_client * client,
-                                    u8 command, u16 value);
  extern s32 i2c_smbus_block_process_call(struct i2c_client *client,
                                          u8 command, u8 length,
                                          u8 *values)
diff --git a/arch/arm/mach-omap1/board-h3.c b/arch/arm/mach-omap1/board-h3.c
index 2ced6d9984d2..adfcd7b51393 100644
--- a/arch/arm/mach-omap1/board-h3.c
+++ b/arch/arm/mach-omap1/board-h3.c
@@ -476,6 +476,10 @@ static struct i2c_board_info __initdata h3_i2c_board_info[] = {
                I2C_BOARD_INFO("tps65013", 0x48),
               /* .irq         = OMAP_GPIO_IRQ(??), */
       },
+        {
+                I2C_BOARD_INFO("isp1301_omap", 0x2d),
+                .irq            = OMAP_GPIO_IRQ(14),
+        },
 };
 static struct omap_gpio_switch h3_gpio_switches[] __initdata = {
diff --git a/arch/arm/mach-omap2/board-h4.c b/arch/arm/mach-omap2/board-h4.c
index d4e3b6fc4705..2fef2c845083 100644
--- a/arch/arm/mach-omap2/board-h4.c
+++ b/arch/arm/mach-omap2/board-h4.c
@@ -18,6 +18,7 @@
 #include <linux/mtd/partitions.h>
 #include <linux/delay.h>
 #include <linux/workqueue.h>
+#include <linux/i2c.h>
 #include <linux/input.h>
 #include <linux/err.h>
 #include <linux/clk.h>
@@ -391,6 +392,13 @@ static struct omap_board_config_kernel h4_config[] = {
        { OMAP_TAG_LCD,         &h4_lcd_config },
 };
+static struct i2c_board_info __initdata h4_i2c_board_info[] = {
+        {
+                I2C_BOARD_INFO("isp1301_omap", 0x2d),
+                .irq            = OMAP_GPIO_IRQ(125),
+        },
+};
 static void __init omap_h4_init(void)
 {
        /*
@@ -411,6 +419,9 @@ static void __init omap_h4_init(void)
        }
 #endif
+        i2c_register_board_info(1, h4_i2c_board_info,
+                        ARRAY_SIZE(h4_i2c_board_info));
        platform_add_devices(h4_devices, ARRAY_SIZE(h4_devices));
        omap_board_config = h4_config;
        omap_board_config_size = ARRAY_SIZE(h4_config);
diff --git a/arch/x86/kernel/rtc.c b/arch/x86/kernel/rtc.c
index 05191bbc68b8..0a23b5795b25 100644
--- a/arch/x86/kernel/rtc.c
+++ b/arch/x86/kernel/rtc.c
@@ -223,11 +223,25 @@ static struct platform_device rtc_device = {
 static __init int add_rtc_cmos(void)
 {
 #ifdef CONFIG_PNP
-        if (!pnp_platform_devices)
+        static const char *ids[] __initconst =
-                platform_device_register(&rtc_device);
+            { "PNP0b00", "PNP0b01", "PNP0b02", };
-#else
+        struct pnp_dev *dev;
+        struct pnp_id *id;
+        int i;
+        pnp_for_each_dev(dev) {
+                for (id = dev->id; id; id = id->next) {
+                        for (i = 0; i < ARRAY_SIZE(ids); i++) {
+                                if (compare_pnp_id(id, ids[i]) != 0)
+                                        return 0;
+                        }
+                }
+        }
+#endif
        platform_device_register(&rtc_device);
-#endif /* CONFIG_PNP */
+        dev_info(&rtc_device.dev,
+                 "registered platform RTC device (no PNP device found)\n");
        return 0;
 }
 device_initcall(add_rtc_cmos);
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 3c578ef78c48..24649ada08df 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -260,115 +260,3 @@ static int __init init_acpi_device_notify(void)
 }
 arch_initcall(init_acpi_device_notify);
-#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
-#ifdef CONFIG_PM
-static u32 rtc_handler(void *context)
-{
-        acpi_clear_event(ACPI_EVENT_RTC);
-        acpi_disable_event(ACPI_EVENT_RTC, 0);
-        return ACPI_INTERRUPT_HANDLED;
-}
-static inline void rtc_wake_setup(void)
-{
-        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
-        /*
-         * After the RTC handler is installed, the Fixed_RTC event should
-         * be disabled. Only when the RTC alarm is set will it be enabled.
-         */
-        acpi_clear_event(ACPI_EVENT_RTC);
-        acpi_disable_event(ACPI_EVENT_RTC, 0);
-}
-static void rtc_wake_on(struct device *dev)
-{
-        acpi_clear_event(ACPI_EVENT_RTC);
-        acpi_enable_event(ACPI_EVENT_RTC, 0);
-}
-static void rtc_wake_off(struct device *dev)
-{
-        acpi_disable_event(ACPI_EVENT_RTC, 0);
-}
-#else
-#define rtc_wake_setup()        do{}while(0)
-#define rtc_wake_on             NULL
-#define rtc_wake_off            NULL
-#endif
-/* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
- * its device node and pass extra config data.  This helps its driver use
- * capabilities that the now-obsolete mc146818 didn't have, and informs it
- * that this board's RTC is wakeup-capable (per ACPI spec).
- */
-#include <linux/mc146818rtc.h>
-static struct cmos_rtc_board_info rtc_info;
-/* PNP devices are registered in a subsys_initcall();
- * ACPI specifies the PNP IDs to use.
- */
-#include <linux/pnp.h>
-static int __init pnp_match(struct device *dev, void *data)
-{
-        static const char *ids[] = { "PNP0b00", "PNP0b01", "PNP0b02", };
-        struct pnp_dev *pnp = to_pnp_dev(dev);
-        int i;
-        for (i = 0; i < ARRAY_SIZE(ids); i++) {
-                if (compare_pnp_id(pnp->id, ids[i]) != 0)
-                        return 1;
-        }
-        return 0;
-}
-static struct device *__init get_rtc_dev(void)
-{
-        return bus_find_device(&pnp_bus_type, NULL, NULL, pnp_match);
-}
-static int __init acpi_rtc_init(void)
-{
-        struct device *dev = get_rtc_dev();
-        if (acpi_disabled)
-                return 0;
-        if (dev) {
-                rtc_wake_setup();
-                rtc_info.wake_on = rtc_wake_on;
-                rtc_info.wake_off = rtc_wake_off;
-                /* workaround bug in some ACPI tables */
-                if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
-                        DBG("bogus FADT month_alarm\n");
-                        acpi_gbl_FADT.month_alarm = 0;
-                }
-                rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
-                rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
-                rtc_info.rtc_century = acpi_gbl_FADT.century;
-                /* NOTE:  S4_RTC_WAKE is NOT currently useful to Linux */
-                if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
-                        printk(PREFIX "RTC can wake from S4\n");
-                dev->platform_data = &rtc_info;
-                /* RTC always wakes from S1/S2/S3, and often S4/STD */
-                device_init_wakeup(dev, 1);
-                put_device(dev);
-        } else
-                DBG("RTC unavailable?\n");
-        return 0;
-}
-module_init(acpi_rtc_init);
-#endif
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index cacf89e65af4..da64108de775 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -17,6 +17,25 @@ config HID
        tristate "Generic HID support"
        depends on INPUT
        default y
+        select HID_A4TECH if !EMBEDDED
+        select HID_APPLE if !EMBEDDED
+        select HID_BELKIN if !EMBEDDED
+        select HID_BRIGHT if !EMBEDDED
+        select HID_CHERRY if !EMBEDDED
+        select HID_CHICONY if !EMBEDDED
+        select HID_CYPRESS if !EMBEDDED
+        select HID_DELL if !EMBEDDED
+        select HID_EZKEY if !EMBEDDED
+        select HID_GYRATION if !EMBEDDED
+        select HID_LOGITECH if !EMBEDDED
+        select HID_MICROSOFT if !EMBEDDED
+        select HID_MONTEREY if !EMBEDDED
+        select HID_PANTHERLORD if !EMBEDDED
+        select HID_PETALYNX if !EMBEDDED
+        select HID_SAMSUNG if !EMBEDDED
+        select HID_SONY if !EMBEDDED
+        select HID_SUNPLUS if !EMBEDDED
        ---help---
          A human interface device (HID) is a type of computer device that
          interacts directly with and takes input from humans. The term "HID"
@@ -67,4 +86,206 @@ config HIDRAW
 source "drivers/hid/usbhid/Kconfig"
+menu "Special HID drivers"
+        depends on HID
+config HID_COMPAT
+        bool "Load all HID drivers on hid core load"
+        default y
+        ---help---
+        Compatible option for older userspace. If you have system without udev
+        support of module loading through aliases and also old
+        module-init-tools which can't handle hid bus, choose Y here. Otherwise
+        say N. If you say N and your userspace is old enough, the only
+        functionality you lose is modules autoloading.
+        If unsure, say Y.
+config HID_A4TECH
+        tristate "A4 tech"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for A4 tech X5 and WOP-35 / Trust 450L mice.
+config HID_APPLE
+        tristate "Apple"
+        default m
+        depends on (USB_HID || BT_HIDP)
+        ---help---
+        Support for some Apple devices which less or more break
+        HID specification.
+        Say Y here if you want support for the special keys (Fn, Numlock) on
+        Apple iBooks, PowerBooks, MacBooks, MacBook Pros and aluminum USB
+        keyboards.
+        If unsure, say M.
+config HID_BELKIN
+        tristate "Belkin"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Belkin Flip KVM and Wireless keyboard.
+config HID_BRIGHT
+        tristate "Bright"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Bright ABNT-2 keyboard.
+config HID_CHERRY
+        tristate "Cherry"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Cherry Cymotion.
+config HID_CHICONY
+        tristate "Chicony"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Chicony Tactical pad.
+config HID_CYPRESS
+        tristate "Cypress"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Cypress mouse and barcodes.
+config HID_DELL
+        tristate "Dell"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Dell W7658.
+config HID_EZKEY
+        tristate "Ezkey"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Ezkey mouse and barcodes.
+config HID_GYRATION
+        tristate "Gyration"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Gyration remote.
+config HID_LOGITECH
+        tristate "Logitech"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for some Logitech devices which breaks less or more
+        HID specification.
+config LOGITECH_FF
+        bool "Logitech force feedback"
+        depends on HID_LOGITECH
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have one of these devices:
+          - Logitech WingMan Cordless RumblePad
+          - Logitech WingMan Cordless RumblePad 2
+          - Logitech WingMan Force 3D
+          - Logitech Formula Force EX
+          - Logitech MOMO Force wheel
+          and if you want to enable force feedback for them.
+          Note: if you say N here, this device will still be supported, but without
+          force feedback.
+config LOGIRUMBLEPAD2_FF
+        bool "Logitech Rumblepad 2 force feedback"
+        depends on HID_LOGITECH
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you want to enable force feedback support for Logitech
+          Rumblepad 2 devices.
+config HID_MICROSOFT
+        tristate "Microsoft"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for some Microsoft devices which breaks less or more
+        HID specification.
+config HID_MONTEREY
+        tristate "Monterey"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Monterey Genius KB29E.
+config HID_PANTHERLORD
+        tristate "Pantherlord devices support"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for PantherLord/GreenAsia based device support.
+config PANTHERLORD_FF
+        bool "Pantherlord force feedback support"
+        depends on HID_PANTHERLORD
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have a PantherLord/GreenAsia based game controller
+          or adapter and want to enable force feedback support for it.
+config HID_PETALYNX
+        tristate "Petalynx"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Petalynx Maxter remote.
+config HID_SAMSUNG
+        tristate "Samsung"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Samsung IR remote.
+config HID_SONY
+        tristate "Sony"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Sony PS3 controller.
+config HID_SUNPLUS
+        tristate "Sunplus"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Sunplus WDesktop input device.
+config THRUSTMASTER_FF
+        tristate "ThrustMaster devices support"
+        default m
+        depends on USB_HID
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
+          a THRUSTMASTER Ferrari GT Rumble Force or Force Feedback Wheel.
+config ZEROPLUS_FF
+        tristate "Zeroplus based game controller support"
+        default m
+        depends on USB_HID
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have a Zeroplus based game controller.
+endmenu
 endif # HID_SUPPORT
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 275dc522c738..b09e43e7413e 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -1,13 +1,46 @@
 #
 # Makefile for the HID driver
 #
-hid-objs                        := hid-core.o hid-input.o hid-input-quirks.o
+hid-objs                        := hid-core.o hid-input.o
 obj-$(CONFIG_HID)               += hid.o
 hid-$(CONFIG_HID_DEBUG)         += hid-debug.o
 hid-$(CONFIG_HIDRAW)            += hidraw.o
+ifdef CONFIG_HID_COMPAT
+obj-m                           += hid-dummy.o
+endif
+hid-logitech-objs               := hid-lg.o
+ifdef CONFIG_LOGITECH_FF
+        hid-logitech-objs       += hid-lgff.o
+endif
+ifdef CONFIG_LOGIRUMBLEPAD2_FF
+        hid-logitech-objs       += hid-lg2ff.o
+endif
+obj-$(CONFIG_HID_A4TECH)        += hid-a4tech.o
+obj-$(CONFIG_HID_APPLE)         += hid-apple.o
+obj-$(CONFIG_HID_BELKIN)        += hid-belkin.o
+obj-$(CONFIG_HID_BRIGHT)        += hid-bright.o
+obj-$(CONFIG_HID_CHERRY)        += hid-cherry.o
+obj-$(CONFIG_HID_CHICONY)       += hid-chicony.o
+obj-$(CONFIG_HID_CYPRESS)       += hid-cypress.o
+obj-$(CONFIG_HID_DELL)          += hid-dell.o
+obj-$(CONFIG_HID_EZKEY)         += hid-ezkey.o
+obj-$(CONFIG_HID_GYRATION)      += hid-gyration.o
+obj-$(CONFIG_HID_LOGITECH)      += hid-logitech.o
+obj-$(CONFIG_HID_MICROSOFT)     += hid-microsoft.o
+obj-$(CONFIG_HID_MONTEREY)      += hid-monterey.o
+obj-$(CONFIG_HID_PANTHERLORD)   += hid-pl.o
+obj-$(CONFIG_HID_PETALYNX)      += hid-petalynx.o
+obj-$(CONFIG_HID_SAMSUNG)       += hid-samsung.o
+obj-$(CONFIG_HID_SONY)          += hid-sony.o
+obj-$(CONFIG_HID_SUNPLUS)       += hid-sunplus.o
+obj-$(CONFIG_THRUSTMASTER_FF)   += hid-tmff.o
+obj-$(CONFIG_ZEROPLUS_FF)       += hid-zpff.o
 obj-$(CONFIG_USB_HID)           += usbhid/
 obj-$(CONFIG_USB_MOUSE)         += usbhid/
 obj-$(CONFIG_USB_KBD)           += usbhid/
diff --git a/drivers/hid/hid-a4tech.c b/drivers/hid/hid-a4tech.c
new file mode 100644
index 000000000000..ebca00e6c103
--- /dev/null
+++ b/drivers/hid/hid-a4tech.c
@@ -0,0 +1,162 @@
+/*
+ *  HID driver for some a4tech "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define A4_2WHEEL_MOUSE_HACK_7  0x01
+#define A4_2WHEEL_MOUSE_HACK_B8 0x02
+struct a4tech_sc {
+        unsigned long quirks;
+        unsigned int hw_wheel;
+        __s32 delayed_value;
+};
+static int a4_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct a4tech_sc *a4 = hid_get_drvdata(hdev);
+        if (usage->type == EV_REL && usage->code == REL_WHEEL)
+                set_bit(REL_HWHEEL, *bit);
+        if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007)
+                return -1;
+        return 0;
+}
+static int a4_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        struct a4tech_sc *a4 = hid_get_drvdata(hdev);
+        struct input_dev *input;
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+        input = field->hidinput->input;
+        if (a4->quirks & A4_2WHEEL_MOUSE_HACK_B8) {
+                if (usage->type == EV_REL && usage->code == REL_WHEEL) {
+                        a4->delayed_value = value;
+                        return 1;
+                }
+                if (usage->hid == 0x000100b8) {
+                        input_event(input, EV_REL, value ? REL_HWHEEL :
+                                        REL_WHEEL, a4->delayed_value);
+                        return 1;
+                }
+        }
+        if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007) {
+                a4->hw_wheel = !!value;
+                return 1;
+        }
+        if (usage->code == REL_WHEEL && a4->hw_wheel) {
+                input_event(input, usage->type, REL_HWHEEL, value);
+                return 1;
+        }
+        return 0;
+}
+static int a4_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        struct a4tech_sc *a4;
+        int ret;
+        a4 = kzalloc(sizeof(*a4), GFP_KERNEL);
+        if (a4 == NULL) {
+                dev_err(&hdev->dev, "can't alloc device descriptor\n");
+                ret = -ENOMEM;
+                goto err_free;
+        }
+        a4->quirks = id->driver_data;
+        hid_set_drvdata(hdev, a4);
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        kfree(a4);
+        return ret;
+}
+static void a4_remove(struct hid_device *hdev)
+{
+        struct a4tech_sc *a4 = hid_get_drvdata(hdev);
+        hid_hw_stop(hdev);
+        kfree(a4);
+}
+static const struct hid_device_id a4_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU),
+                .driver_data = A4_2WHEEL_MOUSE_HACK_7 },
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D),
+                .driver_data = A4_2WHEEL_MOUSE_HACK_B8 },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, a4_devices);
+static struct hid_driver a4_driver = {
+        .name = "a4tech",
+        .id_table = a4_devices,
+        .input_mapped = a4_input_mapped,
+        .event = a4_event,
+        .probe = a4_probe,
+        .remove = a4_remove,
+};
+static int a4_init(void)
+{
+        return hid_register_driver(&a4_driver);
+}
+static void a4_exit(void)
+{
+        hid_unregister_driver(&a4_driver);
+}
+module_init(a4_init);
+module_exit(a4_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(a4tech);
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
new file mode 100644
index 000000000000..fd7f896b34f7
--- /dev/null
+++ b/drivers/hid/hid-apple.c
@@ -0,0 +1,484 @@
+/*
+ *  USB HID quirks support for Linux
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "hid-ids.h"
+#define APPLE_RDESC_JIS         0x0001
+#define APPLE_IGNORE_MOUSE      0x0002
+#define APPLE_HAS_FN            0x0004
+#define APPLE_HIDDEV            0x0008
+#define APPLE_ISO_KEYBOARD      0x0010
+#define APPLE_MIGHTYMOUSE       0x0020
+#define APPLE_INVERT_HWHEEL     0x0040
+#define APPLE_IGNORE_HIDINPUT   0x0080
+#define APPLE_NUMLOCK_EMULATION 0x0100
+#define APPLE_FLAG_FKEY         0x01
+static unsigned int fnmode = 1;
+module_param(fnmode, uint, 0644);
+MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
+                "[1] = fkeyslast, 2 = fkeysfirst)");
+struct apple_sc {
+        unsigned long quirks;
+        unsigned int fn_on;
+        DECLARE_BITMAP(pressed_fn, KEY_CNT);
+        DECLARE_BITMAP(pressed_numlock, KEY_CNT);
+};
+struct apple_key_translation {
+        u16 from;
+        u16 to;
+        u8 flags;
+};
+static struct apple_key_translation apple_fn_keys[] = {
+        { KEY_BACKSPACE, KEY_DELETE },
+        { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
+        { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
+        { KEY_F3,       KEY_FN_F5,          APPLE_FLAG_FKEY }, /* Exposé */
+        { KEY_F4,       KEY_FN_F4,          APPLE_FLAG_FKEY }, /* Dashboard */
+        { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
+        { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
+        { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
+        { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
+        { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
+        { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
+        { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
+        { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
+        { KEY_UP,       KEY_PAGEUP },
+        { KEY_DOWN,     KEY_PAGEDOWN },
+        { KEY_LEFT,     KEY_HOME },
+        { KEY_RIGHT,    KEY_END },
+        { }
+};
+static struct apple_key_translation powerbook_fn_keys[] = {
+        { KEY_BACKSPACE, KEY_DELETE },
+        { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
+        { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
+        { KEY_F3,       KEY_MUTE,               APPLE_FLAG_FKEY },
+        { KEY_F4,       KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
+        { KEY_F5,       KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
+        { KEY_F6,       KEY_NUMLOCK,            APPLE_FLAG_FKEY },
+        { KEY_F7,       KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
+        { KEY_F8,       KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
+        { KEY_F9,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
+        { KEY_F10,      KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
+        { KEY_UP,       KEY_PAGEUP },
+        { KEY_DOWN,     KEY_PAGEDOWN },
+        { KEY_LEFT,     KEY_HOME },
+        { KEY_RIGHT,    KEY_END },
+        { }
+};
+static struct apple_key_translation powerbook_numlock_keys[] = {
+        { KEY_J,        KEY_KP1 },
+        { KEY_K,        KEY_KP2 },
+        { KEY_L,        KEY_KP3 },
+        { KEY_U,        KEY_KP4 },
+        { KEY_I,        KEY_KP5 },
+        { KEY_O,        KEY_KP6 },
+        { KEY_7,        KEY_KP7 },
+        { KEY_8,        KEY_KP8 },
+        { KEY_9,        KEY_KP9 },
+        { KEY_M,        KEY_KP0 },
+        { KEY_DOT,      KEY_KPDOT },
+        { KEY_SLASH,    KEY_KPPLUS },
+        { KEY_SEMICOLON, KEY_KPMINUS },
+        { KEY_P,        KEY_KPASTERISK },
+        { KEY_MINUS,    KEY_KPEQUAL },
+        { KEY_0,        KEY_KPSLASH },
+        { KEY_F6,       KEY_NUMLOCK },
+        { KEY_KPENTER,  KEY_KPENTER },
+        { KEY_BACKSPACE, KEY_BACKSPACE },
+        { }
+};
+static struct apple_key_translation apple_iso_keyboard[] = {
+        { KEY_GRAVE,    KEY_102ND },
+        { KEY_102ND,    KEY_GRAVE },
+        { }
+};
+static struct apple_key_translation *apple_find_translation(
+                struct apple_key_translation *table, u16 from)
+{
+        struct apple_key_translation *trans;
+        /* Look for the translation */
+        for (trans = table; trans->from; trans++)
+                if (trans->from == from)
+                        return trans;
+        return NULL;
+}
+static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
+                struct hid_usage *usage, __s32 value)
+{
+        struct apple_sc *asc = hid_get_drvdata(hid);
+        struct apple_key_translation *trans;
+        if (usage->code == KEY_FN) {
+                asc->fn_on = !!value;
+                input_event(input, usage->type, usage->code, value);
+                return 1;
+        }
+        if (fnmode) {
+                int do_translate;
+                trans = apple_find_translation((hid->product < 0x220 ||
+                                        hid->product >= 0x300) ?
+                                        powerbook_fn_keys : apple_fn_keys,
+                                        usage->code);
+                if (trans) {
+                        if (test_bit(usage->code, asc->pressed_fn))
+                                do_translate = 1;
+                        else if (trans->flags & APPLE_FLAG_FKEY)
+                                do_translate = (fnmode == 2 && asc->fn_on) ||
+                                        (fnmode == 1 && !asc->fn_on);
+                        else
+                                do_translate = asc->fn_on;
+                        if (do_translate) {
+                                if (value)
+                                        set_bit(usage->code, asc->pressed_fn);
+                                else
+                                        clear_bit(usage->code, asc->pressed_fn);
+                                input_event(input, usage->type, trans->to,
+                                                value);
+                                return 1;
+                        }
+                }
+                if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
+                                (test_bit(usage->code, asc->pressed_numlock) ||
+                                test_bit(LED_NUML, input->led))) {
+                        trans = apple_find_translation(powerbook_numlock_keys,
+                                        usage->code);
+                        if (trans) {
+                                if (value)
+                                        set_bit(usage->code,
+                                                        asc->pressed_numlock);
+                                else
+                                        clear_bit(usage->code,
+                                                        asc->pressed_numlock);
+                                input_event(input, usage->type, trans->to,
+                                                value);
+                        }
+                        return 1;
+                }
+        }
+        if (asc->quirks & APPLE_ISO_KEYBOARD) {
+                trans = apple_find_translation(apple_iso_keyboard, usage->code);
+                if (trans) {
+                        input_event(input, usage->type, trans->to, value);
+                        return 1;
+                }
+        }
+        return 0;
+}
+static int apple_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        struct apple_sc *asc = hid_get_drvdata(hdev);
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+        if ((asc->quirks & APPLE_INVERT_HWHEEL) &&
+                        usage->code == REL_HWHEEL) {
+                input_event(field->hidinput->input, usage->type, usage->code,
+                                -value);
+                return 1;
+        }
+        if ((asc->quirks & APPLE_HAS_FN) &&
+                        hidinput_apple_event(hdev, field->hidinput->input,
+                                usage, value))
+                return 1;
+        return 0;
+}
+/*
+ * MacBook JIS keyboard has wrong logical maximum
+ */
+static void apple_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        struct apple_sc *asc = hid_get_drvdata(hdev);
+        if ((asc->quirks & APPLE_RDESC_JIS) && rsize >= 60 &&
+                        rdesc[53] == 0x65 && rdesc[59] == 0x65) {
+                dev_info(&hdev->dev, "fixing up MacBook JIS keyboard report "
+                                "descriptor\n");
+                rdesc[53] = rdesc[59] = 0xe7;
+        }
+}
+static void apple_setup_input(struct input_dev *input)
+{
+        struct apple_key_translation *trans;
+        set_bit(KEY_NUMLOCK, input->keybit);
+        /* Enable all needed keys */
+        for (trans = apple_fn_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+        for (trans = powerbook_fn_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+        for (trans = powerbook_numlock_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+        for (trans = apple_iso_keyboard; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+}
+static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->hid == (HID_UP_CUSTOM | 0x0003)) {
+                /* The fn key on Apple USB keyboards */
+                set_bit(EV_REP, hi->input->evbit);
+                hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
+                apple_setup_input(hi->input);
+                return 1;
+        }
+        /* we want the hid layer to go through standard path (set and ignore) */
+        return 0;
+}
+static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct apple_sc *asc = hid_get_drvdata(hdev);
+        if (asc->quirks & APPLE_MIGHTYMOUSE) {
+                if (usage->hid == HID_GD_Z)
+                        hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
+                else if (usage->code == BTN_1)
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
+                else if (usage->code == BTN_2)
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
+        }
+        return 0;
+}
+static int apple_probe(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        struct apple_sc *asc;
+        unsigned int connect_mask = HID_CONNECT_DEFAULT;
+        int ret;
+        /* return something else or move to hid layer? device will reside
+           allocated */
+        if (id->bus == BUS_USB && (quirks & APPLE_IGNORE_MOUSE) &&
+                        to_usb_interface(hdev->dev.parent)->cur_altsetting->
+                        desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
+                return -ENODEV;
+        asc = kzalloc(sizeof(*asc), GFP_KERNEL);
+        if (asc == NULL) {
+                dev_err(&hdev->dev, "can't alloc apple descriptor\n");
+                return -ENOMEM;
+        }
+        asc->quirks = quirks;
+        hid_set_drvdata(hdev, asc);
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        if (quirks & APPLE_HIDDEV)
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+        if (quirks & APPLE_IGNORE_HIDINPUT)
+                connect_mask &= ~HID_CONNECT_HIDINPUT;
+        ret = hid_hw_start(hdev, connect_mask);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        kfree(asc);
+        return ret;
+}
+static void apple_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+}
+static const struct hid_device_id apple_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL),
+                .driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),
+                .driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
+                .driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS},
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        /* Apple wireless Mighty Mouse */
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c),
+                .driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, apple_devices);
+static struct hid_driver apple_driver = {
+        .name = "apple",
+        .id_table = apple_devices,
+        .report_fixup = apple_report_fixup,
+        .probe = apple_probe,
+        .remove = apple_remove,
+        .event = apple_event,
+        .input_mapping = apple_input_mapping,
+        .input_mapped = apple_input_mapped,
+};
+static int apple_init(void)
+{
+        int ret;
+        ret = hid_register_driver(&apple_driver);
+        if (ret)
+                printk(KERN_ERR "can't register apple driver\n");
+        return ret;
+}
+static void apple_exit(void)
+{
+        hid_unregister_driver(&apple_driver);
+}
+module_init(apple_init);
+module_exit(apple_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(apple);
diff --git a/drivers/hid/hid-belkin.c b/drivers/hid/hid-belkin.c
new file mode 100644
index 000000000000..12c8a9ba6ed6
--- /dev/null
+++ b/drivers/hid/hid-belkin.c
@@ -0,0 +1,105 @@
+/*
+ *  HID driver for some belkin "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define BELKIN_HIDDEV   0x01
+#define BELKIN_WKBD     0x02
+#define belkin_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int belkin_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER ||
+                        !(quirks & BELKIN_WKBD))
+                return 0;
+        switch (usage->hid & HID_USAGE) {
+        case 0x03a: belkin_map_key_clear(KEY_SOUND);            break;
+        case 0x03b: belkin_map_key_clear(KEY_CAMERA);           break;
+        case 0x03c: belkin_map_key_clear(KEY_DOCUMENTS);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int belkin_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        int ret;
+        hid_set_drvdata(hdev, (void *)quirks);
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
+                ((quirks & BELKIN_HIDDEV) ? HID_CONNECT_HIDDEV_FORCE : 0));
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id belkin_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM),
+                .driver_data = BELKIN_HIDDEV },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD),
+                .driver_data = BELKIN_WKBD },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, belkin_devices);
+static struct hid_driver belkin_driver = {
+        .name = "belkin",
+        .id_table = belkin_devices,
+        .input_mapping = belkin_input_mapping,
+        .probe = belkin_probe,
+};
+static int belkin_init(void)
+{
+        return hid_register_driver(&belkin_driver);
+}
+static void belkin_exit(void)
+{
+        hid_unregister_driver(&belkin_driver);
+}
+module_init(belkin_init);
+module_exit(belkin_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(belkin);
diff --git a/drivers/hid/hid-bright.c b/drivers/hid/hid-bright.c
new file mode 100644
index 000000000000..38517a117dfd
--- /dev/null
+++ b/drivers/hid/hid-bright.c
@@ -0,0 +1,71 @@
+/*
+ *  HID driver for some bright "special" devices
+ *
+ *  Copyright (c) 2008 Mauro Carvalho Chehab <mchehab@redhat.com>
+ *
+ * Based on hid-dell driver
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+static int bright_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        usbhid_set_leds(hdev);
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id bright_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_BRIGHT, USB_DEVICE_ID_BRIGHT_ABNT2) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, bright_devices);
+static struct hid_driver bright_driver = {
+        .name = "bright",
+        .id_table = bright_devices,
+        .probe = bright_probe,
+};
+static int bright_init(void)
+{
+        return hid_register_driver(&bright_driver);
+}
+static void bright_exit(void)
+{
+        hid_unregister_driver(&bright_driver);
+}
+module_init(bright_init);
+module_exit(bright_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(bright);
diff --git a/drivers/hid/hid-cherry.c b/drivers/hid/hid-cherry.c
new file mode 100644
index 000000000000..b833b9769aba
--- /dev/null
+++ b/drivers/hid/hid-cherry.c
@@ -0,0 +1,87 @@
+/*
+ *  HID driver for some cherry "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+/*
+ * Cherry Cymotion keyboard have an invalid HID report descriptor,
+ * that needs fixing before we can parse it.
+ */
+static void ch_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 17 && rdesc[11] == 0x3c && rdesc[12] == 0x02) {
+                dev_info(&hdev->dev, "fixing up Cherry Cymotion report "
+                                "descriptor\n");
+                rdesc[11] = rdesc[16] = 0xff;
+                rdesc[12] = rdesc[17] = 0x03;
+        }
+}
+#define ch_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+        switch (usage->hid & HID_USAGE) {
+        case 0x301: ch_map_key_clear(KEY_PROG1);        break;
+        case 0x302: ch_map_key_clear(KEY_PROG2);        break;
+        case 0x303: ch_map_key_clear(KEY_PROG3);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static const struct hid_device_id ch_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ch_devices);
+static struct hid_driver ch_driver = {
+        .name = "cherry",
+        .id_table = ch_devices,
+        .report_fixup = ch_report_fixup,
+        .input_mapping = ch_input_mapping,
+};
+static int ch_init(void)
+{
+        return hid_register_driver(&ch_driver);
+}
+static void ch_exit(void)
+{
+        hid_unregister_driver(&ch_driver);
+}
+module_init(ch_init);
+module_exit(ch_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(cherry);
diff --git a/drivers/hid/hid-chicony.c b/drivers/hid/hid-chicony.c
new file mode 100644
index 000000000000..a54d4096e0f7
--- /dev/null
+++ b/drivers/hid/hid-chicony.c
@@ -0,0 +1,80 @@
+/*
+ *  HID driver for some chicony "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define ch_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
+                return 0;
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        case 0xff01: ch_map_key_clear(BTN_1);   break;
+        case 0xff02: ch_map_key_clear(BTN_2);   break;
+        case 0xff03: ch_map_key_clear(BTN_3);   break;
+        case 0xff04: ch_map_key_clear(BTN_4);   break;
+        case 0xff05: ch_map_key_clear(BTN_5);   break;
+        case 0xff06: ch_map_key_clear(BTN_6);   break;
+        case 0xff07: ch_map_key_clear(BTN_7);   break;
+        case 0xff08: ch_map_key_clear(BTN_8);   break;
+        case 0xff09: ch_map_key_clear(BTN_9);   break;
+        case 0xff0a: ch_map_key_clear(BTN_A);   break;
+        case 0xff0b: ch_map_key_clear(BTN_B);   break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static const struct hid_device_id ch_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ch_devices);
+static struct hid_driver ch_driver = {
+        .name = "chicony",
+        .id_table = ch_devices,
+        .input_mapping = ch_input_mapping,
+};
+static int ch_init(void)
+{
+        return hid_register_driver(&ch_driver);
+}
+static void ch_exit(void)
+{
+        hid_unregister_driver(&ch_driver);
+}
+module_init(ch_init);
+module_exit(ch_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(chicony);
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 426ac5add585..8a7d9dbb4d07 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -33,6 +33,8 @@
 #include <linux/hid-debug.h>
 #include <linux/hidraw.h>
+#include "hid-ids.h"
 /*
 * Version Information
 */
@@ -268,9 +270,9 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
 static u32 item_udata(struct hid_item *item)
 {
        switch (item->size) {
-                case 1: return item->data.u8;
+        case 1: return item->data.u8;
-                case 2: return item->data.u16;
+        case 2: return item->data.u16;
-                case 4: return item->data.u32;
+        case 4: return item->data.u32;
        }
        return 0;
 }
@@ -278,9 +280,9 @@ static u32 item_udata(struct hid_item *item)
 static s32 item_sdata(struct hid_item *item)
 {
        switch (item->size) {
-                case 1: return item->data.s8;
+        case 1: return item->data.s8;
-                case 2: return item->data.s16;
+        case 2: return item->data.s16;
-                case 4: return item->data.s32;
+        case 4: return item->data.s32;
        }
        return 0;
 }
@@ -292,87 +294,91 @@ static s32 item_sdata(struct hid_item *item)
 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 {
        switch (item->tag) {
+        case HID_GLOBAL_ITEM_TAG_PUSH:
-                case HID_GLOBAL_ITEM_TAG_PUSH:
+                if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
+                        dbg_hid("global enviroment stack overflow\n");
-                        if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
+                        return -1;
-                                dbg_hid("global enviroment stack overflow\n");
+                }
-                                return -1;
-                        }
-                        memcpy(parser->global_stack + parser->global_stack_ptr++,
+                memcpy(parser->global_stack + parser->global_stack_ptr++,
-                                &parser->global, sizeof(struct hid_global));
+                        &parser->global, sizeof(struct hid_global));
-                        return 0;
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_POP:
+        case HID_GLOBAL_ITEM_TAG_POP:
-                        if (!parser->global_stack_ptr) {
+                if (!parser->global_stack_ptr) {
-                                dbg_hid("global enviroment stack underflow\n");
+                        dbg_hid("global enviroment stack underflow\n");
-                                return -1;
+                        return -1;
-                        }
+                }
-                        memcpy(&parser->global, parser->global_stack + --parser->global_stack_ptr,
-                                sizeof(struct hid_global));
-                        return 0;
-                case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
+                memcpy(&parser->global, parser->global_stack +
-                        parser->global.usage_page = item_udata(item);
+                        --parser->global_stack_ptr, sizeof(struct hid_global));
-                        return 0;
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
+        case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
-                        parser->global.logical_minimum = item_sdata(item);
+                parser->global.usage_page = item_udata(item);
-                        return 0;
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
+        case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
-                        if (parser->global.logical_minimum < 0)
+                parser->global.logical_minimum = item_sdata(item);
-                                parser->global.logical_maximum = item_sdata(item);
+                return 0;
-                        else
-                                parser->global.logical_maximum = item_udata(item);
-                        return 0;
-                case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
+        case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
-                        parser->global.physical_minimum = item_sdata(item);
+                if (parser->global.logical_minimum < 0)
-                        return 0;
+                        parser->global.logical_maximum = item_sdata(item);
+                else
+                        parser->global.logical_maximum = item_udata(item);
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
+        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
-                        if (parser->global.physical_minimum < 0)
+                parser->global.physical_minimum = item_sdata(item);
-                                parser->global.physical_maximum = item_sdata(item);
+                return 0;
-                        else
-                                parser->global.physical_maximum = item_udata(item);
-                        return 0;
-                case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
+        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
-                        parser->global.unit_exponent = item_sdata(item);
+                if (parser->global.physical_minimum < 0)
-                        return 0;
+                        parser->global.physical_maximum = item_sdata(item);
+                else
+                        parser->global.physical_maximum = item_udata(item);
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_UNIT:
+        case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
-                        parser->global.unit = item_udata(item);
+                parser->global.unit_exponent = item_sdata(item);
-                        return 0;
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
+        case HID_GLOBAL_ITEM_TAG_UNIT:
-                        if ((parser->global.report_size = item_udata(item)) > 32) {
+                parser->global.unit = item_udata(item);
-                                dbg_hid("invalid report_size %d\n", parser->global.report_size);
+                return 0;
-                                return -1;
-                        }
-                        return 0;
-                case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
+        case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
-                        if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
+                parser->global.report_size = item_udata(item);
-                                dbg_hid("invalid report_count %d\n", parser->global.report_count);
+                if (parser->global.report_size > 32) {
-                                return -1;
+                        dbg_hid("invalid report_size %d\n",
-                        }
+                                        parser->global.report_size);
-                        return 0;
+                        return -1;
+                }
+                return 0;
-                case HID_GLOBAL_ITEM_TAG_REPORT_ID:
+        case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
-                        if ((parser->global.report_id = item_udata(item)) == 0) {
+                parser->global.report_count = item_udata(item);
-                                dbg_hid("report_id 0 is invalid\n");
+                if (parser->global.report_count > HID_MAX_USAGES) {
-                                return -1;
+                        dbg_hid("invalid report_count %d\n",
-                        }
+                                        parser->global.report_count);
-                        return 0;
+                        return -1;
+                }
+                return 0;
-                default:
+        case HID_GLOBAL_ITEM_TAG_REPORT_ID:
-                        dbg_hid("unknown global tag 0x%x\n", item->tag);
+                parser->global.report_id = item_udata(item);
+                if (parser->global.report_id == 0) {
+                        dbg_hid("report_id 0 is invalid\n");
                        return -1;
+                }
+                return 0;
+        default:
+                dbg_hid("unknown global tag 0x%x\n", item->tag);
+                return -1;
        }
 }
@@ -393,77 +399,76 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
        data = item_udata(item);
        switch (item->tag) {
+        case HID_LOCAL_ITEM_TAG_DELIMITER:
-                case HID_LOCAL_ITEM_TAG_DELIMITER:
+                if (data) {
-                        if (data) {
+                        /*
-                                /*
+                         * We treat items before the first delimiter
-                                 * We treat items before the first delimiter
+                         * as global to all usage sets (branch 0).
-                                 * as global to all usage sets (branch 0).
+                         * In the moment we process only these global
-                                 * In the moment we process only these global
+                         * items and the first delimiter set.
-                                 * items and the first delimiter set.
+                         */
-                                 */
+                        if (parser->local.delimiter_depth != 0) {
-                                if (parser->local.delimiter_depth != 0) {
+                                dbg_hid("nested delimiters\n");
-                                        dbg_hid("nested delimiters\n");
+                                return -1;
-                                        return -1;
-                                }
-                                parser->local.delimiter_depth++;
-                                parser->local.delimiter_branch++;
-                        } else {
-                                if (parser->local.delimiter_depth < 1) {
-                                        dbg_hid("bogus close delimiter\n");
-                                        return -1;
-                                }
-                                parser->local.delimiter_depth--;
                        }
-                        return 1;
+                        parser->local.delimiter_depth++;
+                        parser->local.delimiter_branch++;
-                case HID_LOCAL_ITEM_TAG_USAGE:
+                } else {
+                        if (parser->local.delimiter_depth < 1) {
-                        if (parser->local.delimiter_branch > 1) {
+                                dbg_hid("bogus close delimiter\n");
-                                dbg_hid("alternative usage ignored\n");
+                                return -1;
-                                return 0;
                        }
+                        parser->local.delimiter_depth--;
+                }
+                return 1;
-                        if (item->size <= 2)
+        case HID_LOCAL_ITEM_TAG_USAGE:
-                                data = (parser->global.usage_page << 16) + data;
-                        return hid_add_usage(parser, data);
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
+                        return 0;
+                }
-                case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
-                        if (parser->local.delimiter_branch > 1) {
+                return hid_add_usage(parser, data);
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
-                        }
-                        if (item->size <= 2)
+        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
-                                data = (parser->global.usage_page << 16) + data;
-                        parser->local.usage_minimum = data;
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
                        return 0;
+                }
-                case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
-                        if (parser->local.delimiter_branch > 1) {
+                parser->local.usage_minimum = data;
-                                dbg_hid("alternative usage ignored\n");
+                return 0;
-                                return 0;
-                        }
-                        if (item->size <= 2)
+        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
-                                data = (parser->global.usage_page << 16) + data;
-                        for (n = parser->local.usage_minimum; n <= data; n++)
+                if (parser->local.delimiter_branch > 1) {
-                                if (hid_add_usage(parser, n)) {
+                        dbg_hid("alternative usage ignored\n");
-                                        dbg_hid("hid_add_usage failed\n");
-                                        return -1;
-                                }
                        return 0;
+                }
-                default:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
-                        dbg_hid("unknown local item tag 0x%x\n", item->tag);
+                for (n = parser->local.usage_minimum; n <= data; n++)
-                        return 0;
+                        if (hid_add_usage(parser, n)) {
+                                dbg_hid("hid_add_usage failed\n");
+                                return -1;
+                        }
+                return 0;
+        default:
+                dbg_hid("unknown local item tag 0x%x\n", item->tag);
+                return 0;
        }
        return 0;
 }
@@ -480,24 +485,24 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
        data = item_udata(item);
        switch (item->tag) {
-                case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
+        case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
-                        ret = open_collection(parser, data & 0xff);
+                ret = open_collection(parser, data & 0xff);
-                        break;
+                break;
-                case HID_MAIN_ITEM_TAG_END_COLLECTION:
+        case HID_MAIN_ITEM_TAG_END_COLLECTION:
-                        ret = close_collection(parser);
+                ret = close_collection(parser);
-                        break;
+                break;
-                case HID_MAIN_ITEM_TAG_INPUT:
+        case HID_MAIN_ITEM_TAG_INPUT:
-                        ret = hid_add_field(parser, HID_INPUT_REPORT, data);
+                ret = hid_add_field(parser, HID_INPUT_REPORT, data);
-                        break;
+                break;
-                case HID_MAIN_ITEM_TAG_OUTPUT:
+        case HID_MAIN_ITEM_TAG_OUTPUT:
-                        ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
+                ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
-                        break;
+                break;
-                case HID_MAIN_ITEM_TAG_FEATURE:
+        case HID_MAIN_ITEM_TAG_FEATURE:
-                        ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
+                ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
-                        break;
+                break;
-                default:
+        default:
-                        dbg_hid("unknown main item tag 0x%x\n", item->tag);
+                dbg_hid("unknown main item tag 0x%x\n", item->tag);
-                        ret = 0;
+                ret = 0;
        }
        memset(&parser->local, 0, sizeof(parser->local));       /* Reset the local parser environment */
@@ -534,9 +539,10 @@ static void hid_free_report(struct hid_report *report)
 * Free a device structure, all reports, and all fields.
 */
-void hid_free_device(struct hid_device *device)
+static void hid_device_release(struct device *dev)
 {
-        unsigned i,j;
+        struct hid_device *device = container_of(dev, struct hid_device, dev);
+        unsigned i, j;
        for (i = 0; i < HID_REPORT_TYPES; i++) {
                struct hid_report_enum *report_enum = device->report_enum + i;
@@ -552,7 +558,6 @@ void hid_free_device(struct hid_device *device)
        kfree(device->collection);
        kfree(device);
 }
-EXPORT_SYMBOL_GPL(hid_free_device);
 /*
 * Fetch a report description item from the data stream. We support long
@@ -593,47 +598,52 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
        item->size = b & 3;
        switch (item->size) {
+        case 0:
+                return start;
-                case 0:
+        case 1:
-                        return start;
+                if ((end - start) < 1)
+                        return NULL;
-                case 1:
+                item->data.u8 = *start++;
-                        if ((end - start) < 1)
+                return start;
-                                return NULL;
-                        item->data.u8 = *start++;
-                        return start;
-                case 2:
+        case 2:
-                        if ((end - start) < 2)
+                if ((end - start) < 2)
-                                return NULL;
+                        return NULL;
-                        item->data.u16 = get_unaligned_le16(start);
+                item->data.u16 = get_unaligned_le16(start);
-                        start = (__u8 *)((__le16 *)start + 1);
+                start = (__u8 *)((__le16 *)start + 1);
-                        return start;
+                return start;
-                case 3:
+        case 3:
-                        item->size++;
+                item->size++;
-                        if ((end - start) < 4)
+                if ((end - start) < 4)
-                                return NULL;
+                        return NULL;
-                        item->data.u32 = get_unaligned_le32(start);
+                item->data.u32 = get_unaligned_le32(start);
-                        start = (__u8 *)((__le32 *)start + 1);
+                start = (__u8 *)((__le32 *)start + 1);
-                        return start;
+                return start;
        }
        return NULL;
 }
-/*
+/**
+ * hid_parse_report - parse device report
+ *
+ * @device: hid device
+ * @start: report start
+ * @size: report size
+ *
 * Parse a report description into a hid_device structure. Reports are
 * enumerated, fields are attached to these reports.
+ * 0 returned on success, otherwise nonzero error value.
 */
+int hid_parse_report(struct hid_device *device, __u8 *start,
-struct hid_device *hid_parse_report(__u8 *start, unsigned size)
+                unsigned size)
 {
-        struct hid_device *device;
        struct hid_parser *parser;
        struct hid_item item;
        __u8 *end;
-        unsigned i;
+        int ret;
        static int (*dispatch_type[])(struct hid_parser *parser,
                                      struct hid_item *item) = {
                hid_parser_main,
@@ -642,76 +652,57 @@ struct hid_device *hid_parse_report(__u8 *start, unsigned size)
                hid_parser_reserved
        };
-        if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
+        if (device->driver->report_fixup)
-                return NULL;
+                device->driver->report_fixup(device, start, size);
-        if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
+        device->rdesc = kmalloc(size, GFP_KERNEL);
-                                   HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) {
+        if (device->rdesc == NULL)
-                kfree(device);
+                return -ENOMEM;
-                return NULL;
-        }
-        device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
-        for (i = 0; i < HID_REPORT_TYPES; i++)
-                INIT_LIST_HEAD(&device->report_enum[i].report_list);
-        if (!(device->rdesc = kmalloc(size, GFP_KERNEL))) {
-                kfree(device->collection);
-                kfree(device);
-                return NULL;
-        }
        memcpy(device->rdesc, start, size);
        device->rsize = size;
-        if (!(parser = vmalloc(sizeof(struct hid_parser)))) {
+        parser = vmalloc(sizeof(struct hid_parser));
-                kfree(device->rdesc);
+        if (!parser) {
-                kfree(device->collection);
+                ret = -ENOMEM;
-                kfree(device);
+                goto err;
-                return NULL;
        }
        memset(parser, 0, sizeof(struct hid_parser));
        parser->device = device;
        end = start + size;
+        ret = -EINVAL;
        while ((start = fetch_item(start, end, &item)) != NULL) {
                if (item.format != HID_ITEM_FORMAT_SHORT) {
                        dbg_hid("unexpected long global item\n");
-                        hid_free_device(device);
+                        goto err;
-                        vfree(parser);
-                        return NULL;
                }
                if (dispatch_type[item.type](parser, &item)) {
                        dbg_hid("item %u %u %u %u parsing failed\n",
                                item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
-                        hid_free_device(device);
+                        goto err;
-                        vfree(parser);
-                        return NULL;
                }
                if (start == end) {
                        if (parser->collection_stack_ptr) {
                                dbg_hid("unbalanced collection at end of report description\n");
-                                hid_free_device(device);
+                                goto err;
-                                vfree(parser);
-                                return NULL;
                        }
                        if (parser->local.delimiter_depth) {
                                dbg_hid("unbalanced delimiter at end of report description\n");
-                                hid_free_device(device);
+                                goto err;
-                                vfree(parser);
-                                return NULL;
                        }
                        vfree(parser);
-                        return device;
+                        return 0;
                }
        }
        dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
-        hid_free_device(device);
+err:
        vfree(parser);
-        return NULL;
+        return ret;
 }
 EXPORT_SYMBOL_GPL(hid_parse_report);
@@ -724,9 +715,9 @@ EXPORT_SYMBOL_GPL(hid_parse_report);
 static s32 snto32(__u32 value, unsigned n)
 {
        switch (n) {
-                case 8:  return ((__s8)value);
+        case 8:  return ((__s8)value);
-                case 16: return ((__s16)value);
+        case 16: return ((__s16)value);
-                case 32: return ((__s32)value);
+        case 32: return ((__s32)value);
        }
        return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 }
@@ -815,9 +806,73 @@ static __inline__ int search(__s32 *array, __s32 value, unsigned n)
        return -1;
 }
-static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, int interrupt)
+/**
+ * hid_match_report - check if driver's raw_event should be called
+ *
+ * @hid: hid device
+ * @report_type: type to match against
+ *
+ * compare hid->driver->report_table->report_type to report->type
+ */
+static int hid_match_report(struct hid_device *hid, struct hid_report *report)
+{
+        const struct hid_report_id *id = hid->driver->report_table;
+        if (!id) /* NULL means all */
+                return 1;
+        for (; id->report_type != HID_TERMINATOR; id++)
+                if (id->report_type == HID_ANY_ID ||
+                                id->report_type == report->type)
+                        return 1;
+        return 0;
+}
+/**
+ * hid_match_usage - check if driver's event should be called
+ *
+ * @hid: hid device
+ * @usage: usage to match against
+ *
+ * compare hid->driver->usage_table->usage_{type,code} to
+ * usage->usage_{type,code}
+ */
+static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
 {
+        const struct hid_usage_id *id = hid->driver->usage_table;
+        if (!id) /* NULL means all */
+                return 1;
+        for (; id->usage_type != HID_ANY_ID - 1; id++)
+                if ((id->usage_hid == HID_ANY_ID ||
+                                id->usage_hid == usage->hid) &&
+                                (id->usage_type == HID_ANY_ID ||
+                                id->usage_type == usage->type) &&
+                                (id->usage_code == HID_ANY_ID ||
+                                 id->usage_code == usage->code))
+                        return 1;
+        return 0;
+}
+static void hid_process_event(struct hid_device *hid, struct hid_field *field,
+                struct hid_usage *usage, __s32 value, int interrupt)
+{
+        struct hid_driver *hdrv = hid->driver;
+        int ret;
        hid_dump_input(usage, value);
+        if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
+                ret = hdrv->event(hid, field, usage, value);
+                if (ret != 0) {
+                        if (ret < 0)
+                                dbg_hid("%s's event failed with %d\n",
+                                                hdrv->name, ret);
+                        return;
+                }
+        }
        if (hid->claimed & HID_CLAIMED_INPUT)
                hidinput_hid_event(hid, field, usage, value);
        if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
@@ -946,44 +1001,47 @@ int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 }
 EXPORT_SYMBOL_GPL(hid_set_field);
-int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
+static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
+                const u8 *data)
 {
-        struct hid_report_enum *report_enum = hid->report_enum + type;
        struct hid_report *report;
-        int n, rsize, i;
+        unsigned int n = 0;     /* Normally report number is 0 */
-        if (!hid)
+        /* Device uses numbered reports, data[0] is report number */
-                return -ENODEV;
+        if (report_enum->numbered)
+                n = *data;
-        if (!size) {
+        report = report_enum->report_id_hash[n];
-                dbg_hid("empty report\n");
+        if (report == NULL)
-                return -1;
+                dbg_hid("undefined report_id %u received\n", n);
-        }
-        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+        return report;
+}
-        n = 0;                          /* Normally report number is 0 */
+void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
-        if (report_enum->numbered) {    /* Device uses numbered reports, data[0] is report number */
+                int interrupt)
-                n = *data++;
+{
-                size--;
+        struct hid_report_enum *report_enum = hid->report_enum + type;
-        }
+        struct hid_report *report;
+        unsigned int a;
+        int rsize, csize = size;
+        u8 *cdata = data;
-        /* dump the report */
+        report = hid_get_report(report_enum, data);
-        dbg_hid("report %d (size %u) = ", n, size);
+        if (!report)
-        for (i = 0; i < size; i++)
+                return;
-                dbg_hid_line(" %02x", data[i]);
-        dbg_hid_line("\n");
-        if (!(report = report_enum->report_id_hash[n])) {
+        if (report_enum->numbered) {
-                dbg_hid("undefined report_id %d received\n", n);
+                cdata++;
-                return -1;
+                csize--;
        }
        rsize = ((report->size - 1) >> 3) + 1;
-        if (size < rsize) {
+        if (csize < rsize) {
-                dbg_hid("report %d is too short, (%d < %d)\n", report->id, size, rsize);
+                dbg_hid("report %d is too short, (%d < %d)\n", report->id,
-                memset(data + size, 0, rsize - size);
+                                csize, rsize);
+                memset(cdata + csize, 0, rsize - csize);
        }
        if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
@@ -996,24 +1054,661 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                        hidraw_report_event(hid, data, size);
        }
-        for (n = 0; n < report->maxfield; n++)
+        for (a = 0; a < report->maxfield; a++)
-                hid_input_field(hid, report->field[n], data, interrupt);
+                hid_input_field(hid, report->field[a], cdata, interrupt);
        if (hid->claimed & HID_CLAIMED_INPUT)
                hidinput_report_event(hid, report);
+}
+EXPORT_SYMBOL_GPL(hid_report_raw_event);
+/**
+ * hid_input_report - report data from lower layer (usb, bt...)
+ *
+ * @hid: hid device
+ * @type: HID report type (HID_*_REPORT)
+ * @data: report contents
+ * @size: size of data parameter
+ * @interrupt: called from atomic?
+ *
+ * This is data entry for lower layers.
+ */
+int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
+{
+        struct hid_report_enum *report_enum = hid->report_enum + type;
+        struct hid_driver *hdrv = hid->driver;
+        struct hid_report *report;
+        unsigned int i;
+        int ret;
+        if (!hid || !hid->driver)
+                return -ENODEV;
+        if (!size) {
+                dbg_hid("empty report\n");
+                return -1;
+        }
+        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+        report = hid_get_report(report_enum, data);
+        if (!report)
+                return -1;
+        /* dump the report */
+        dbg_hid("report %d (size %u) = ", report->id, size);
+        for (i = 0; i < size; i++)
+                dbg_hid_line(" %02x", data[i]);
+        dbg_hid_line("\n");
+        if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
+                ret = hdrv->raw_event(hid, report, data, size);
+                if (ret != 0)
+                        return ret < 0 ? ret : 0;
+        }
+        hid_report_raw_event(hid, type, data, size, interrupt);
        return 0;
 }
 EXPORT_SYMBOL_GPL(hid_input_report);
+static bool hid_match_one_id(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        return id->bus == hdev->bus &&
+                (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
+                (id->product == HID_ANY_ID || id->product == hdev->product);
+}
+static const struct hid_device_id *hid_match_id(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        for (; id->bus; id++)
+                if (hid_match_one_id(hdev, id))
+                        return id;
+        return NULL;
+}
+static const struct hid_device_id hid_hiddev_list[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
+        { }
+};
+static bool hid_hiddev(struct hid_device *hdev)
+{
+        return !!hid_match_id(hdev, hid_hiddev_list);
+}
+int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
+{
+        static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
+                "Joystick", "Gamepad", "Keyboard", "Keypad",
+                "Multi-Axis Controller"
+        };
+        const char *type, *bus;
+        char buf[64];
+        unsigned int i;
+        int len;
+        if (hdev->bus != BUS_USB)
+                connect_mask &= ~HID_CONNECT_HIDDEV;
+        if (hid_hiddev(hdev))
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+        if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
+                                connect_mask & HID_CONNECT_HIDINPUT_FORCE))
+                hdev->claimed |= HID_CLAIMED_INPUT;
+        if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
+                        !hdev->hiddev_connect(hdev,
+                                connect_mask & HID_CONNECT_HIDDEV_FORCE))
+                hdev->claimed |= HID_CLAIMED_HIDDEV;
+        if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
+                hdev->claimed |= HID_CLAIMED_HIDRAW;
+        if (!hdev->claimed) {
+                dev_err(&hdev->dev, "claimed by neither input, hiddev nor "
+                                "hidraw\n");
+                return -ENODEV;
+        }
+        if ((hdev->claimed & HID_CLAIMED_INPUT) &&
+                        (connect_mask & HID_CONNECT_FF) && hdev->ff_init)
+                hdev->ff_init(hdev);
+        len = 0;
+        if (hdev->claimed & HID_CLAIMED_INPUT)
+                len += sprintf(buf + len, "input");
+        if (hdev->claimed & HID_CLAIMED_HIDDEV)
+                len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
+                                hdev->minor);
+        if (hdev->claimed & HID_CLAIMED_HIDRAW)
+                len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
+                                ((struct hidraw *)hdev->hidraw)->minor);
+        type = "Device";
+        for (i = 0; i < hdev->maxcollection; i++) {
+                struct hid_collection *col = &hdev->collection[i];
+                if (col->type == HID_COLLECTION_APPLICATION &&
+                   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
+                   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
+                        type = types[col->usage & 0xffff];
+                        break;
+                }
+        }
+        switch (hdev->bus) {
+        case BUS_USB:
+                bus = "USB";
+                break;
+        case BUS_BLUETOOTH:
+                bus = "BLUETOOTH";
+                break;
+        default:
+                bus = "<UNKNOWN>";
+        }
+        dev_info(&hdev->dev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
+                        buf, bus, hdev->version >> 8, hdev->version & 0xff,
+                        type, hdev->name, hdev->phys);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(hid_connect);
+static const struct hid_device_id hid_blacklist[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_BRIGHT, USB_DEVICE_ID_BRIGHT_ABNT2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_LX3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
+        { }
+};
+static int hid_bus_match(struct device *dev, struct device_driver *drv)
+{
+        struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        if (!hid_match_id(hdev, hdrv->id_table))
+                return 0;
+        /* generic wants all non-blacklisted */
+        if (!strncmp(hdrv->name, "generic-", 8))
+                return !hid_match_id(hdev, hid_blacklist);
+        return 1;
+}
+static int hid_device_probe(struct device *dev)
+{
+        struct hid_driver *hdrv = container_of(dev->driver,
+                        struct hid_driver, driver);
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        const struct hid_device_id *id;
+        int ret = 0;
+        if (!hdev->driver) {
+                id = hid_match_id(hdev, hdrv->id_table);
+                if (id == NULL)
+                        return -ENODEV;
+                hdev->driver = hdrv;
+                if (hdrv->probe) {
+                        ret = hdrv->probe(hdev, id);
+                } else { /* default probe */
+                        ret = hid_parse(hdev);
+                        if (!ret)
+                                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+                }
+                if (ret)
+                        hdev->driver = NULL;
+        }
+        return ret;
+}
+static int hid_device_remove(struct device *dev)
+{
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        struct hid_driver *hdrv = hdev->driver;
+        if (hdrv) {
+                if (hdrv->remove)
+                        hdrv->remove(hdev);
+                else /* default remove */
+                        hid_hw_stop(hdev);
+                hdev->driver = NULL;
+        }
+        return 0;
+}
+static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
+                        hdev->bus, hdev->vendor, hdev->product))
+                return -ENOMEM;
+        if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
+                return -ENOMEM;
+        if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
+                return -ENOMEM;
+        if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
+                return -ENOMEM;
+        if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",
+                        hdev->bus, hdev->vendor, hdev->product))
+                return -ENOMEM;
+        return 0;
+}
+static struct bus_type hid_bus_type = {
+        .name           = "hid",
+        .match          = hid_bus_match,
+        .probe          = hid_device_probe,
+        .remove         = hid_device_remove,
+        .uevent         = hid_uevent,
+};
+static const struct hid_device_id hid_ignore_list[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+        { }
+};
+static bool hid_ignore(struct hid_device *hdev)
+{
+        switch (hdev->vendor) {
+        case USB_VENDOR_ID_CODEMERCS:
+                /* ignore all Code Mercenaries IOWarrior devices */
+                if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
+                                hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
+                        return true;
+                break;
+        case USB_VENDOR_ID_LOGITECH:
+                if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&
+                                hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)
+                        return true;
+                break;
+        }
+        return !!hid_match_id(hdev, hid_ignore_list);
+}
+int hid_add_device(struct hid_device *hdev)
+{
+        static atomic_t id = ATOMIC_INIT(0);
+        int ret;
+        if (WARN_ON(hdev->status & HID_STAT_ADDED))
+                return -EBUSY;
+        /* we need to kill them here, otherwise they will stay allocated to
+         * wait for coming driver */
+        if (hid_ignore(hdev))
+                return -ENODEV;
+        /* XXX hack, any other cleaner solution < 20 bus_id bytes? */
+        sprintf(hdev->dev.bus_id, "%04X:%04X:%04X.%04X", hdev->bus,
+                        hdev->vendor, hdev->product, atomic_inc_return(&id));
+        ret = device_add(&hdev->dev);
+        if (!ret)
+                hdev->status |= HID_STAT_ADDED;
+        return ret;
+}
+EXPORT_SYMBOL_GPL(hid_add_device);
+/**
+ * hid_allocate_device - allocate new hid device descriptor
+ *
+ * Allocate and initialize hid device, so that hid_destroy_device might be
+ * used to free it.
+ *
+ * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
+ * error value.
+ */
+struct hid_device *hid_allocate_device(void)
+{
+        struct hid_device *hdev;
+        unsigned int i;
+        int ret = -ENOMEM;
+        hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
+        if (hdev == NULL)
+                return ERR_PTR(ret);
+        device_initialize(&hdev->dev);
+        hdev->dev.release = hid_device_release;
+        hdev->dev.bus = &hid_bus_type;
+        hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
+                        sizeof(struct hid_collection), GFP_KERNEL);
+        if (hdev->collection == NULL)
+                goto err;
+        hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
+        for (i = 0; i < HID_REPORT_TYPES; i++)
+                INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
+        return hdev;
+err:
+        put_device(&hdev->dev);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(hid_allocate_device);
+static void hid_remove_device(struct hid_device *hdev)
+{
+        if (hdev->status & HID_STAT_ADDED) {
+                device_del(&hdev->dev);
+                hdev->status &= ~HID_STAT_ADDED;
+        }
+}
+/**
+ * hid_destroy_device - free previously allocated device
+ *
+ * @hdev: hid device
+ *
+ * If you allocate hid_device through hid_allocate_device, you should ever
+ * free by this function.
+ */
+void hid_destroy_device(struct hid_device *hdev)
+{
+        hid_remove_device(hdev);
+        put_device(&hdev->dev);
+}
+EXPORT_SYMBOL_GPL(hid_destroy_device);
+int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
+                const char *mod_name)
+{
+        hdrv->driver.name = hdrv->name;
+        hdrv->driver.bus = &hid_bus_type;
+        hdrv->driver.owner = owner;
+        hdrv->driver.mod_name = mod_name;
+        return driver_register(&hdrv->driver);
+}
+EXPORT_SYMBOL_GPL(__hid_register_driver);
+void hid_unregister_driver(struct hid_driver *hdrv)
+{
+        driver_unregister(&hdrv->driver);
+}
+EXPORT_SYMBOL_GPL(hid_unregister_driver);
+#ifdef CONFIG_HID_COMPAT
+static void hid_compat_load(struct work_struct *ws)
+{
+        request_module("hid-dummy");
+}
+static DECLARE_WORK(hid_compat_work, hid_compat_load);
+static struct workqueue_struct *hid_compat_wq;
+#endif
 static int __init hid_init(void)
 {
-        return hidraw_init();
+        int ret;
+        ret = bus_register(&hid_bus_type);
+        if (ret) {
+                printk(KERN_ERR "HID: can't register hid bus\n");
+                goto err;
+        }
+        ret = hidraw_init();
+        if (ret)
+                goto err_bus;
+#ifdef CONFIG_HID_COMPAT
+        hid_compat_wq = create_workqueue("hid_compat");
+        if (!hid_compat_wq) {
+                hidraw_exit();
+                goto err;
+        }
+        queue_work(hid_compat_wq, &hid_compat_work);
+#endif
+        return 0;
+err_bus:
+        bus_unregister(&hid_bus_type);
+err:
+        return ret;
 }
 static void __exit hid_exit(void)
 {
+#ifdef CONFIG_HID_COMPAT
+        destroy_workqueue(hid_compat_wq);
+#endif
        hidraw_exit();
+        bus_unregister(&hid_bus_type);
 }
 module_init(hid_init);
diff --git a/drivers/hid/hid-cypress.c b/drivers/hid/hid-cypress.c
new file mode 100644
index 000000000000..5d69d27b935d
--- /dev/null
+++ b/drivers/hid/hid-cypress.c
@@ -0,0 +1,158 @@
+/*
+ *  HID driver for some cypress "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define CP_RDESC_SWAPPED_MIN_MAX        0x01
+#define CP_2WHEEL_MOUSE_HACK            0x02
+#define CP_2WHEEL_MOUSE_HACK_ON         0x04
+/*
+ * Some USB barcode readers from cypress have usage min and usage max in
+ * the wrong order
+ */
+static void cp_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        unsigned int i;
+        if (!(quirks & CP_RDESC_SWAPPED_MIN_MAX))
+                return;
+        for (i = 0; i < rsize - 4; i++)
+                if (rdesc[i] == 0x29 && rdesc[i + 2] == 0x19) {
+                        __u8 tmp;
+                        rdesc[i] = 0x19;
+                        rdesc[i + 2] = 0x29;
+                        tmp = rdesc[i + 3];
+                        rdesc[i + 3] = rdesc[i + 1];
+                        rdesc[i + 1] = tmp;
+                }
+}
+static int cp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if (!(quirks & CP_2WHEEL_MOUSE_HACK))
+                return 0;
+        if (usage->type == EV_REL && usage->code == REL_WHEEL)
+                set_bit(REL_HWHEEL, *bit);
+        if (usage->hid == 0x00090005)
+                return -1;
+        return 0;
+}
+static int cp_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type || !(quirks & CP_2WHEEL_MOUSE_HACK))
+                return 0;
+        if (usage->hid == 0x00090005) {
+                if (value)
+                        quirks |=  CP_2WHEEL_MOUSE_HACK_ON;
+                else
+                        quirks &= ~CP_2WHEEL_MOUSE_HACK_ON;
+                hid_set_drvdata(hdev, (void *)quirks);
+                return 1;
+        }
+        if (usage->code == REL_WHEEL && (quirks & CP_2WHEEL_MOUSE_HACK_ON)) {
+                struct input_dev *input = field->hidinput->input;
+                input_event(input, usage->type, REL_HWHEEL, value);
+                return 1;
+        }
+        return 0;
+}
+static int cp_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        int ret;
+        hid_set_drvdata(hdev, (void *)quirks);
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id cp_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1),
+                .driver_data = CP_RDESC_SWAPPED_MIN_MAX },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2),
+                .driver_data = CP_RDESC_SWAPPED_MIN_MAX },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE),
+                .driver_data = CP_2WHEEL_MOUSE_HACK },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, cp_devices);
+static struct hid_driver cp_driver = {
+        .name = "cypress",
+        .id_table = cp_devices,
+        .report_fixup = cp_report_fixup,
+        .input_mapped = cp_input_mapped,
+        .event = cp_event,
+        .probe = cp_probe,
+};
+static int cp_init(void)
+{
+        return hid_register_driver(&cp_driver);
+}
+static void cp_exit(void)
+{
+        hid_unregister_driver(&cp_driver);
+}
+module_init(cp_init);
+module_exit(cp_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(cypress);
diff --git a/drivers/hid/hid-dell.c b/drivers/hid/hid-dell.c
new file mode 100644
index 000000000000..1a0d0dfc62fc
--- /dev/null
+++ b/drivers/hid/hid-dell.c
@@ -0,0 +1,75 @@
+/*
+ *  HID driver for some dell "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+static int dell_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        usbhid_set_leds(hdev);
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id dell_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, dell_devices);
+static struct hid_driver dell_driver = {
+        .name = "dell",
+        .id_table = dell_devices,
+        .probe = dell_probe,
+};
+static int dell_init(void)
+{
+        return hid_register_driver(&dell_driver);
+}
+static void dell_exit(void)
+{
+        hid_unregister_driver(&dell_driver);
+}
+module_init(dell_init);
+module_exit(dell_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(dell);
diff --git a/drivers/hid/hid-dummy.c b/drivers/hid/hid-dummy.c
new file mode 100644
index 000000000000..e148f86fb58e
--- /dev/null
+++ b/drivers/hid/hid-dummy.c
@@ -0,0 +1,72 @@
+#include <linux/autoconf.h>
+#include <linux/module.h>
+#include <linux/hid.h>
+static int __init hid_dummy_init(void)
+{
+#ifdef CONFIG_HID_A4TECH_MODULE
+        HID_COMPAT_CALL_DRIVER(a4tech);
+#endif
+#ifdef CONFIG_HID_APPLE_MODULE
+        HID_COMPAT_CALL_DRIVER(apple);
+#endif
+#ifdef CONFIG_HID_BELKIN_MODULE
+        HID_COMPAT_CALL_DRIVER(belkin);
+#endif
+#ifdef CONFIG_HID_BRIGHT_MODULE
+        HID_COMPAT_CALL_DRIVER(bright);
+#endif
+#ifdef CONFIG_HID_CHERRY_MODULE
+        HID_COMPAT_CALL_DRIVER(cherry);
+#endif
+#ifdef CONFIG_HID_CHICONY_MODULE
+        HID_COMPAT_CALL_DRIVER(chicony);
+#endif
+#ifdef CONFIG_HID_CYPRESS_MODULE
+        HID_COMPAT_CALL_DRIVER(cypress);
+#endif
+#ifdef CONFIG_HID_DELL_MODULE
+        HID_COMPAT_CALL_DRIVER(dell);
+#endif
+#ifdef CONFIG_HID_EZKEY_MODULE
+        HID_COMPAT_CALL_DRIVER(ezkey);
+#endif
+#ifdef CONFIG_HID_GYRATION_MODULE
+        HID_COMPAT_CALL_DRIVER(gyration);
+#endif
+#ifdef CONFIG_HID_LOGITECH_MODULE
+        HID_COMPAT_CALL_DRIVER(logitech);
+#endif
+#ifdef CONFIG_HID_MICROSOFT_MODULE
+        HID_COMPAT_CALL_DRIVER(microsoft);
+#endif
+#ifdef CONFIG_HID_MONTEREY_MODULE
+        HID_COMPAT_CALL_DRIVER(monterey);
+#endif
+#ifdef CONFIG_HID_PANTHERLORD_MODULE
+        HID_COMPAT_CALL_DRIVER(pantherlord);
+#endif
+#ifdef CONFIG_HID_PETALYNX_MODULE
+        HID_COMPAT_CALL_DRIVER(petalynx);
+#endif
+#ifdef CONFIG_HID_SAMSUNG_MODULE
+        HID_COMPAT_CALL_DRIVER(samsung);
+#endif
+#ifdef CONFIG_HID_SONY_MODULE
+        HID_COMPAT_CALL_DRIVER(sony);
+#endif
+#ifdef CONFIG_HID_SUNPLUS_MODULE
+        HID_COMPAT_CALL_DRIVER(sunplus);
+#endif
+#ifdef CONFIG_THRUSTMASTER_FF_MODULE
+        HID_COMPAT_CALL_DRIVER(thrustmaster);
+#endif
+#ifdef CONFIG_ZEROPLUS_FF_MODULE
+        HID_COMPAT_CALL_DRIVER(zeroplus);
+#endif
+        return -EIO;
+}
+module_init(hid_dummy_init);
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-ezkey.c b/drivers/hid/hid-ezkey.c
new file mode 100644
index 000000000000..deb42f931b7e
--- /dev/null
+++ b/drivers/hid/hid-ezkey.c
@@ -0,0 +1,95 @@
+/*
+ *  HID driver for some ezkey "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define ez_map_rel(c)   hid_map_usage(hi, usage, bit, max, EV_REL, (c))
+#define ez_map_key(c)   hid_map_usage(hi, usage, bit, max, EV_KEY, (c))
+static int ez_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+        switch (usage->hid & HID_USAGE) {
+        case 0x230: ez_map_key(BTN_MOUSE);      break;
+        case 0x231: ez_map_rel(REL_WHEEL);      break;
+        /*
+         * this keyboard has a scrollwheel implemented in
+         * totally broken way. We map this usage temporarily
+         * to HWHEEL and handle it in the event quirk handler
+         */
+        case 0x232: ez_map_rel(REL_HWHEEL);     break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int ez_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+        /* handle the temporary quirky mapping to HWHEEL */
+        if (usage->type == EV_REL && usage->code == REL_HWHEEL) {
+                struct input_dev *input = field->hidinput->input;
+                input_event(input, usage->type, REL_WHEEL, -value);
+                return 1;
+        }
+        return 0;
+}
+static const struct hid_device_id ez_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ez_devices);
+static struct hid_driver ez_driver = {
+        .name = "ezkey",
+        .id_table = ez_devices,
+        .input_mapping = ez_input_mapping,
+        .event = ez_event,
+};
+static int ez_init(void)
+{
+        return hid_register_driver(&ez_driver);
+}
+static void ez_exit(void)
+{
+        hid_unregister_driver(&ez_driver);
+}
+module_init(ez_init);
+module_exit(ez_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(ezkey);
diff --git a/drivers/hid/hid-gyration.c b/drivers/hid/hid-gyration.c
new file mode 100644
index 000000000000..ac5120f542cc
--- /dev/null
+++ b/drivers/hid/hid-gyration.c
@@ -0,0 +1,96 @@
+/*
+ *  HID driver for some gyration "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define gy_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int gyration_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
+                return 0;
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        /* Reported on Gyration MCE Remote */
+        case 0x00d: gy_map_key_clear(KEY_HOME);         break;
+        case 0x024: gy_map_key_clear(KEY_DVD);          break;
+        case 0x025: gy_map_key_clear(KEY_PVR);          break;
+        case 0x046: gy_map_key_clear(KEY_MEDIA);        break;
+        case 0x047: gy_map_key_clear(KEY_MP3);          break;
+        case 0x049: gy_map_key_clear(KEY_CAMERA);       break;
+        case 0x04a: gy_map_key_clear(KEY_VIDEO);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int gyration_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        struct input_dev *input = field->hidinput->input;
+        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
+                        (usage->hid & 0xff) == 0x82) {
+                input_event(input, usage->type, usage->code, 1);
+                input_sync(input);
+                input_event(input, usage->type, usage->code, 0);
+                input_sync(input);
+                return 1;
+        }
+        return 0;
+}
+static const struct hid_device_id gyration_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, gyration_devices);
+static struct hid_driver gyration_driver = {
+        .name = "gyration",
+        .id_table = gyration_devices,
+        .input_mapping = gyration_input_mapping,
+        .event = gyration_event,
+};
+static int gyration_init(void)
+{
+        return hid_register_driver(&gyration_driver);
+}
+static void gyration_exit(void)
+{
+        hid_unregister_driver(&gyration_driver);
+}
+module_init(gyration_init);
+module_exit(gyration_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(gyration);
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
new file mode 100644
index 000000000000..aad9ed1b406e
--- /dev/null
+++ b/drivers/hid/hid-ids.h
@@ -0,0 +1,404 @@
+/*
+ *  USB HID quirks support for Linux
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#ifndef HID_IDS_H_FILE
+#define HID_IDS_H_FILE
+#define USB_VENDOR_ID_A4TECH            0x09da
+#define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
+#define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
+#define USB_VENDOR_ID_AASHIMA           0x06d6
+#define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
+#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
+#define USB_VENDOR_ID_ACECAD            0x0460
+#define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
+#define USB_DEVICE_ID_ACECAD_302        0x0008
+#define USB_VENDOR_ID_ADS_TECH          0x06e1
+#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X     0xa155
+#define USB_VENDOR_ID_AFATECH           0x15a4
+#define USB_DEVICE_ID_AFATECH_AF9016    0x9016
+#define USB_VENDOR_ID_AIPTEK            0x08ca
+#define USB_DEVICE_ID_AIPTEK_01         0x0001
+#define USB_DEVICE_ID_AIPTEK_10         0x0010
+#define USB_DEVICE_ID_AIPTEK_20         0x0020
+#define USB_DEVICE_ID_AIPTEK_21         0x0021
+#define USB_DEVICE_ID_AIPTEK_22         0x0022
+#define USB_DEVICE_ID_AIPTEK_23         0x0023
+#define USB_DEVICE_ID_AIPTEK_24         0x0024
+#define USB_VENDOR_ID_AIRCABLE          0x16CA
+#define USB_DEVICE_ID_AIRCABLE1         0x1502
+#define USB_VENDOR_ID_ALCOR             0x058f
+#define USB_DEVICE_ID_ALCOR_USBRS232    0x9720
+#define USB_VENDOR_ID_ALPS              0x0433
+#define USB_DEVICE_ID_IBM_GAMEPAD       0x1101
+#define USB_VENDOR_ID_APPLE             0x05ac
+#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
+#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
+#define USB_DEVICE_ID_APPLE_GEYSER_ISO  0x0215
+#define USB_DEVICE_ID_APPLE_GEYSER_JIS  0x0216
+#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI        0x0217
+#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218
+#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219
+#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI        0x021a
+#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
+#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
+#define USB_DEVICE_ID_APPLE_ALU_ANSI    0x0220
+#define USB_DEVICE_ID_APPLE_ALU_ISO     0x0221
+#define USB_DEVICE_ID_APPLE_ALU_JIS     0x0222
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
+#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI    0x0229
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO     0x022a
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS     0x022b
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI  0x022c
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO   0x022d
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS   0x022e
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
+#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
+#define USB_DEVICE_ID_APPLE_ATV_IRCONTROL       0x8241
+#define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
+#define USB_VENDOR_ID_ASUS              0x0b05
+#define USB_DEVICE_ID_ASUS_LCM          0x1726
+#define USB_VENDOR_ID_ATEN              0x0557
+#define USB_DEVICE_ID_ATEN_UC100KM      0x2004
+#define USB_DEVICE_ID_ATEN_CS124U       0x2202
+#define USB_DEVICE_ID_ATEN_2PORTKVM     0x2204
+#define USB_DEVICE_ID_ATEN_4PORTKVM     0x2205
+#define USB_DEVICE_ID_ATEN_4PORTKVMC    0x2208
+#define USB_VENDOR_ID_AVERMEDIA         0x07ca
+#define USB_DEVICE_ID_AVER_FM_MR800     0xb800
+#define USB_VENDOR_ID_BELKIN           0x050d
+#define USB_DEVICE_ID_FLIP_KVM         0x3201
+#define USB_VENDOR_ID_BRIGHT            0x1241
+#define USB_DEVICE_ID_BRIGHT_ABNT2      0x1503
+#define USB_VENDOR_ID_BERKSHIRE         0x0c98
+#define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
+#define USB_VENDOR_ID_CHERRY            0x046a
+#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
+#define USB_VENDOR_ID_CHIC              0x05fe
+#define USB_DEVICE_ID_CHIC_GAMEPAD      0x0014
+#define USB_VENDOR_ID_CHICONY           0x04f2
+#define USB_DEVICE_ID_CHICONY_TACTICAL_PAD      0x0418
+#define USB_VENDOR_ID_CIDC              0x1677
+#define USB_VENDOR_ID_CMEDIA            0x0d8c
+#define USB_DEVICE_ID_CM109             0x000e
+#define USB_VENDOR_ID_CODEMERCS         0x07c0
+#define USB_DEVICE_ID_CODEMERCS_IOW_FIRST       0x1500
+#define USB_DEVICE_ID_CODEMERCS_IOW_LAST        0x15ff
+#define USB_VENDOR_ID_CYGNAL            0x10c4
+#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X       0x818a
+#define USB_VENDOR_ID_CYPRESS           0x04b4
+#define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
+#define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
+#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
+#define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
+#define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
+#define USB_VENDOR_ID_DELL              0x413c
+#define USB_DEVICE_ID_DELL_W7658        0x2005
+#define USB_DEVICE_ID_DELL_SK8115       0x2105
+#define USB_VENDOR_ID_DELORME           0x1163
+#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
+#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
+#define USB_VENDOR_ID_DMI               0x0c0b
+#define USB_DEVICE_ID_DMI_ENC           0x5fab
+#define USB_VENDOR_ID_ELO               0x04E7
+#define USB_DEVICE_ID_ELO_TS2700        0x0020
+#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
+#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
+#define USB_VENDOR_ID_EZKEY             0x0518
+#define USB_DEVICE_ID_BTC_8193          0x0002
+#define USB_VENDOR_ID_GAMERON           0x0810
+#define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR  0x0001
+#define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
+#define USB_VENDOR_ID_GLAB              0x06c2
+#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
+#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039
+#define USB_DEVICE_ID_0_0_4_IF_KIT      0x0040
+#define USB_DEVICE_ID_0_16_16_IF_KIT    0x0044
+#define USB_DEVICE_ID_8_8_8_IF_KIT      0x0045
+#define USB_DEVICE_ID_0_8_7_IF_KIT      0x0051
+#define USB_DEVICE_ID_0_8_8_IF_KIT      0x0053
+#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL      0x0058
+#define USB_VENDOR_ID_GOTOP             0x08f2
+#define USB_DEVICE_ID_SUPER_Q2          0x007f
+#define USB_DEVICE_ID_GOGOPEN           0x00ce
+#define USB_DEVICE_ID_PENPOWER          0x00f4
+#define USB_VENDOR_ID_GREENASIA         0x0e8f
+#define USB_VENDOR_ID_GRETAGMACBETH     0x0971
+#define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
+#define USB_VENDOR_ID_GRIFFIN           0x077d
+#define USB_DEVICE_ID_POWERMATE         0x0410
+#define USB_DEVICE_ID_SOUNDKNOB         0x04AA
+#define USB_VENDOR_ID_GTCO              0x078c
+#define USB_DEVICE_ID_GTCO_90           0x0090
+#define USB_DEVICE_ID_GTCO_100          0x0100
+#define USB_DEVICE_ID_GTCO_101          0x0101
+#define USB_DEVICE_ID_GTCO_103          0x0103
+#define USB_DEVICE_ID_GTCO_104          0x0104
+#define USB_DEVICE_ID_GTCO_105          0x0105
+#define USB_DEVICE_ID_GTCO_106          0x0106
+#define USB_DEVICE_ID_GTCO_107          0x0107
+#define USB_DEVICE_ID_GTCO_108          0x0108
+#define USB_DEVICE_ID_GTCO_200          0x0200
+#define USB_DEVICE_ID_GTCO_201          0x0201
+#define USB_DEVICE_ID_GTCO_202          0x0202
+#define USB_DEVICE_ID_GTCO_203          0x0203
+#define USB_DEVICE_ID_GTCO_204          0x0204
+#define USB_DEVICE_ID_GTCO_205          0x0205
+#define USB_DEVICE_ID_GTCO_206          0x0206
+#define USB_DEVICE_ID_GTCO_207          0x0207
+#define USB_DEVICE_ID_GTCO_300          0x0300
+#define USB_DEVICE_ID_GTCO_301          0x0301
+#define USB_DEVICE_ID_GTCO_302          0x0302
+#define USB_DEVICE_ID_GTCO_303          0x0303
+#define USB_DEVICE_ID_GTCO_304          0x0304
+#define USB_DEVICE_ID_GTCO_305          0x0305
+#define USB_DEVICE_ID_GTCO_306          0x0306
+#define USB_DEVICE_ID_GTCO_307          0x0307
+#define USB_DEVICE_ID_GTCO_308          0x0308
+#define USB_DEVICE_ID_GTCO_309          0x0309
+#define USB_DEVICE_ID_GTCO_400          0x0400
+#define USB_DEVICE_ID_GTCO_401          0x0401
+#define USB_DEVICE_ID_GTCO_402          0x0402
+#define USB_DEVICE_ID_GTCO_403          0x0403
+#define USB_DEVICE_ID_GTCO_404          0x0404
+#define USB_DEVICE_ID_GTCO_405          0x0405
+#define USB_DEVICE_ID_GTCO_500          0x0500
+#define USB_DEVICE_ID_GTCO_501          0x0501
+#define USB_DEVICE_ID_GTCO_502          0x0502
+#define USB_DEVICE_ID_GTCO_503          0x0503
+#define USB_DEVICE_ID_GTCO_504          0x0504
+#define USB_DEVICE_ID_GTCO_1000         0x1000
+#define USB_DEVICE_ID_GTCO_1001         0x1001
+#define USB_DEVICE_ID_GTCO_1002         0x1002
+#define USB_DEVICE_ID_GTCO_1003         0x1003
+#define USB_DEVICE_ID_GTCO_1004         0x1004
+#define USB_DEVICE_ID_GTCO_1005         0x1005
+#define USB_DEVICE_ID_GTCO_1006         0x1006
+#define USB_DEVICE_ID_GTCO_1007         0x1007
+#define USB_VENDOR_ID_GYRATION          0x0c16
+#define USB_DEVICE_ID_GYRATION_REMOTE   0x0002
+#define USB_VENDOR_ID_HAPP              0x078b
+#define USB_DEVICE_ID_UGCI_DRIVING      0x0010
+#define USB_DEVICE_ID_UGCI_FLYING       0x0020
+#define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
+#define USB_VENDOR_ID_IMATION           0x0718
+#define USB_DEVICE_ID_DISC_STAKKA       0xd000
+#define USB_VENDOR_ID_KBGEAR            0x084e
+#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
+#define USB_VENDOR_ID_LABTEC            0x1020
+#define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD  0x0006
+#define USB_VENDOR_ID_LD                0x0f11
+#define USB_DEVICE_ID_LD_CASSY          0x1000
+#define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
+#define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
+#define USB_DEVICE_ID_LD_JWM            0x1080
+#define USB_DEVICE_ID_LD_DMMP           0x1081
+#define USB_DEVICE_ID_LD_UMIP           0x1090
+#define USB_DEVICE_ID_LD_XRAY1          0x1100
+#define USB_DEVICE_ID_LD_XRAY2          0x1101
+#define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
+#define USB_DEVICE_ID_LD_COM3LAB        0x2000
+#define USB_DEVICE_ID_LD_TELEPORT       0x2010
+#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
+#define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
+#define USB_DEVICE_ID_LD_MACHINETEST    0x2040
+#define USB_VENDOR_ID_LOGITECH          0x046d
+#define USB_DEVICE_ID_LOGITECH_LX3      0xc044
+#define USB_DEVICE_ID_LOGITECH_V150     0xc047
+#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
+#define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST  0xc110
+#define USB_DEVICE_ID_LOGITECH_HARMONY_LAST 0xc14f
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD        0xc211
+#define USB_DEVICE_ID_LOGITECH_EXTREME_3D       0xc215
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2       0xc218
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2     0xc219
+#define USB_DEVICE_ID_LOGITECH_WINGMAN_F3D      0xc283
+#define USB_DEVICE_ID_LOGITECH_FORCE3D_PRO      0xc286
+#define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL       0xc295
+#define USB_DEVICE_ID_LOGITECH_ELITE_KBD        0xc30a
+#define USB_DEVICE_ID_LOGITECH_KBD      0xc311
+#define USB_DEVICE_ID_S510_RECEIVER     0xc50c
+#define USB_DEVICE_ID_S510_RECEIVER_2   0xc517
+#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500   0xc512
+#define USB_DEVICE_ID_MX3000_RECEIVER   0xc513
+#define USB_DEVICE_ID_DINOVO_DESKTOP    0xc704
+#define USB_DEVICE_ID_DINOVO_EDGE       0xc714
+#define USB_DEVICE_ID_DINOVO_MINI       0xc71f
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2      0xca03
+#define USB_VENDOR_ID_MCC               0x09db
+#define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
+#define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
+#define USB_VENDOR_ID_MGE               0x0463
+#define USB_DEVICE_ID_MGE_UPS           0xffff
+#define USB_DEVICE_ID_MGE_UPS1          0x0001
+#define USB_VENDOR_ID_MICROCHIP         0x04d8
+#define USB_DEVICE_ID_PICKIT1           0x0032
+#define USB_DEVICE_ID_PICKIT2           0x0033
+#define USB_VENDOR_ID_MICROSOFT         0x045e
+#define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
+#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
+#define USB_DEVICE_ID_MS_NE4K           0x00db
+#define USB_DEVICE_ID_MS_LK6K           0x00f9
+#define USB_DEVICE_ID_MS_PRESENTER_8K_BT        0x0701
+#define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
+#define USB_VENDOR_ID_MONTEREY          0x0566
+#define USB_DEVICE_ID_GENIUS_KB29E      0x3004
+#define USB_VENDOR_ID_NCR               0x0404
+#define USB_DEVICE_ID_NCR_FIRST         0x0300
+#define USB_DEVICE_ID_NCR_LAST          0x03ff
+#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
+#define USB_DEVICE_ID_N_S_HARMONY       0xc359
+#define USB_VENDOR_ID_NATSU             0x08b7
+#define USB_DEVICE_ID_NATSU_GAMEPAD     0x0001
+#define USB_VENDOR_ID_NEC               0x073e
+#define USB_DEVICE_ID_NEC_USB_GAME_PAD  0x0301
+#define USB_VENDOR_ID_ONTRAK            0x0a07
+#define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
+#define USB_VENDOR_ID_PANJIT            0x134c
+#define USB_VENDOR_ID_PANTHERLORD       0x0810
+#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
+#define USB_VENDOR_ID_PETALYNX          0x18b1
+#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE    0x0037
+#define USB_VENDOR_ID_PLAYDOTCOM        0x0b43
+#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII      0x0003
+#define USB_VENDOR_ID_SAITEK            0x06a3
+#define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
+#define USB_VENDOR_ID_SAMSUNG           0x0419
+#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
+#define USB_VENDOR_ID_SONY                      0x054c
+#define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
+#define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
+#define USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD       0x0038
+#define USB_VENDOR_ID_SUN               0x0430
+#define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
+#define USB_VENDOR_ID_SUNPLUS           0x04fc
+#define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
+#define USB_VENDOR_ID_TENX              0x1130
+#define USB_DEVICE_ID_TENX_IBUDDY1      0x0001
+#define USB_DEVICE_ID_TENX_IBUDDY2      0x0002
+#define USB_VENDOR_ID_THRUSTMASTER      0x044f
+#define USB_VENDOR_ID_TOPMAX            0x0663
+#define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
+#define USB_VENDOR_ID_TURBOX            0x062a
+#define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
+#define USB_VENDOR_ID_VERNIER           0x08f7
+#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
+#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
+#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
+#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
+#define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
+#define USB_VENDOR_ID_WACOM             0x056a
+#define USB_VENDOR_ID_WISEGROUP         0x0925
+#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101
+#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104
+#define USB_DEVICE_ID_8_8_4_IF_KIT      0x8201
+#define USB_DEVICE_ID_QUAD_USB_JOYPAD   0x8800
+#define USB_DEVICE_ID_DUAL_USB_JOYPAD   0x8866
+#define USB_VENDOR_ID_WISEGROUP_LTD     0x6666
+#define USB_VENDOR_ID_WISEGROUP_LTD2    0x6677
+#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
+#define USB_VENDOR_ID_YEALINK           0x6993
+#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K       0xb001
+#define USB_VENDOR_ID_ZEROPLUS          0x0c12
+#define USB_VENDOR_ID_KYE               0x0458
+#define USB_DEVICE_ID_KYE_GPEN_560      0x5003
+#endif
diff --git a/drivers/hid/hid-input-quirks.c b/drivers/hid/hid-input-quirks.c
deleted file mode 100644
index 16feea014494..000000000000
--- a/drivers/hid/hid-input-quirks.c
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- *  HID-input usage mapping quirks
- *
- *  This is used to handle HID-input mappings for devices violating
- *  HUT 1.12 specification.
- *
- * Copyright (c) 2007-2008 Jiri Kosina
- */
-/*
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License
- */
-#include <linux/input.h>
-#include <linux/hid.h>
-#define map_abs(c)      do { usage->code = c; usage->type = EV_ABS; *bit = input->absbit; *max = ABS_MAX; } while (0)
-#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; *bit = input->relbit; *max = REL_MAX; } while (0)
-#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; *bit = input->keybit; *max = KEY_MAX; } while (0)
-#define map_led(c)      do { usage->code = c; usage->type = EV_LED; *bit = input->ledbit; *max = LED_MAX; } while (0)
-#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, *bit); } while (0)
-#define map_key_clear(c)        do { map_key(c); clear_bit(c, *bit); } while (0)
-static int quirk_belkin_wkbd(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-        switch (usage->hid & HID_USAGE) {
-                case 0x03a: map_key_clear(KEY_SOUND);           break;
-                case 0x03b: map_key_clear(KEY_CAMERA);          break;
-                case 0x03c: map_key_clear(KEY_DOCUMENTS);       break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_cherry_cymotion(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-        switch (usage->hid & HID_USAGE) {
-                case 0x301: map_key_clear(KEY_PROG1);           break;
-                case 0x302: map_key_clear(KEY_PROG2);           break;
-                case 0x303: map_key_clear(KEY_PROG3);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_logitech_ultrax_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
-                return 0;
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                /* Reported on Logitech Ultra X Media Remote */
-                case 0x004: map_key_clear(KEY_AGAIN);           break;
-                case 0x00d: map_key_clear(KEY_HOME);            break;
-                case 0x024: map_key_clear(KEY_SHUFFLE);         break;
-                case 0x025: map_key_clear(KEY_TV);              break;
-                case 0x026: map_key_clear(KEY_MENU);            break;
-                case 0x031: map_key_clear(KEY_AUDIO);           break;
-                case 0x032: map_key_clear(KEY_TEXT);            break;
-                case 0x033: map_key_clear(KEY_LAST);            break;
-                case 0x047: map_key_clear(KEY_MP3);             break;
-                case 0x048: map_key_clear(KEY_DVD);             break;
-                case 0x049: map_key_clear(KEY_MEDIA);           break;
-                case 0x04a: map_key_clear(KEY_VIDEO);           break;
-                case 0x04b: map_key_clear(KEY_ANGLE);           break;
-                case 0x04c: map_key_clear(KEY_LANGUAGE);        break;
-                case 0x04d: map_key_clear(KEY_SUBTITLE);        break;
-                case 0x051: map_key_clear(KEY_RED);             break;
-                case 0x052: map_key_clear(KEY_CLOSE);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_gyration_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
-                return 0;
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                /* Reported on Gyration MCE Remote */
-                case 0x00d: map_key_clear(KEY_HOME);            break;
-                case 0x024: map_key_clear(KEY_DVD);             break;
-                case 0x025: map_key_clear(KEY_PVR);             break;
-                case 0x046: map_key_clear(KEY_MEDIA);           break;
-                case 0x047: map_key_clear(KEY_MP3);             break;
-                case 0x049: map_key_clear(KEY_CAMERA);          break;
-                case 0x04a: map_key_clear(KEY_VIDEO);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_chicony_tactical_pad(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-        set_bit(EV_REP, input->evbit);
-        switch (usage->hid & HID_USAGE) {
-                case 0xff01: map_key_clear(BTN_1);              break;
-                case 0xff02: map_key_clear(BTN_2);              break;
-                case 0xff03: map_key_clear(BTN_3);              break;
-                case 0xff04: map_key_clear(BTN_4);              break;
-                case 0xff05: map_key_clear(BTN_5);              break;
-                case 0xff06: map_key_clear(BTN_6);              break;
-                case 0xff07: map_key_clear(BTN_7);              break;
-                case 0xff08: map_key_clear(BTN_8);              break;
-                case 0xff09: map_key_clear(BTN_9);              break;
-                case 0xff0a: map_key_clear(BTN_A);              break;
-                case 0xff0b: map_key_clear(BTN_B);              break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_microsoft_ergonomy_kb(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-        switch(usage->hid & HID_USAGE) {
-                case 0xfd06: map_key_clear(KEY_CHAT);           break;
-                case 0xfd07: map_key_clear(KEY_PHONE);          break;
-                case 0xff05:
-                        set_bit(EV_REP, input->evbit);
-                        map_key_clear(KEY_F13);
-                        set_bit(KEY_F14, input->keybit);
-                        set_bit(KEY_F15, input->keybit);
-                        set_bit(KEY_F16, input->keybit);
-                        set_bit(KEY_F17, input->keybit);
-                        set_bit(KEY_F18, input->keybit);
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_microsoft_presenter_8k(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                case 0xfd08: map_key_clear(KEY_FORWARD);        break;
-                case 0xfd09: map_key_clear(KEY_BACK);           break;
-                case 0xfd0b: map_key_clear(KEY_PLAYPAUSE);      break;
-                case 0xfd0e: map_key_clear(KEY_CLOSE);          break;
-                case 0xfd0f: map_key_clear(KEY_PLAY);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_petalynx_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if (((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) &&
-                        ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER))
-                return 0;
-        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR)
-                switch(usage->hid & HID_USAGE) {
-                        case 0x05a: map_key_clear(KEY_TEXT);            break;
-                        case 0x05b: map_key_clear(KEY_RED);             break;
-                        case 0x05c: map_key_clear(KEY_GREEN);           break;
-                        case 0x05d: map_key_clear(KEY_YELLOW);          break;
-                        case 0x05e: map_key_clear(KEY_BLUE);            break;
-                        default:
-                                return 0;
-                }
-        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
-                switch(usage->hid & HID_USAGE) {
-                        case 0x0f6: map_key_clear(KEY_NEXT);            break;
-                        case 0x0fa: map_key_clear(KEY_BACK);            break;
-                        default:
-                                return 0;
-                }
-        return 1;
-}
-static int quirk_logitech_wireless(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-        switch (usage->hid & HID_USAGE) {
-                case 0x1001: map_key_clear(KEY_MESSENGER);      break;
-                case 0x1003: map_key_clear(KEY_SOUND);          break;
-                case 0x1004: map_key_clear(KEY_VIDEO);          break;
-                case 0x1005: map_key_clear(KEY_AUDIO);          break;
-                case 0x100a: map_key_clear(KEY_DOCUMENTS);      break;
-                case 0x1011: map_key_clear(KEY_PREVIOUSSONG);   break;
-                case 0x1012: map_key_clear(KEY_NEXTSONG);       break;
-                case 0x1013: map_key_clear(KEY_CAMERA);         break;
-                case 0x1014: map_key_clear(KEY_MESSENGER);      break;
-                case 0x1015: map_key_clear(KEY_RECORD);         break;
-                case 0x1016: map_key_clear(KEY_PLAYER);         break;
-                case 0x1017: map_key_clear(KEY_EJECTCD);        break;
-                case 0x1018: map_key_clear(KEY_MEDIA);          break;
-                case 0x1019: map_key_clear(KEY_PROG1);          break;
-                case 0x101a: map_key_clear(KEY_PROG2);          break;
-                case 0x101b: map_key_clear(KEY_PROG3);          break;
-                case 0x101f: map_key_clear(KEY_ZOOMIN);         break;
-                case 0x1020: map_key_clear(KEY_ZOOMOUT);        break;
-                case 0x1021: map_key_clear(KEY_ZOOMRESET);      break;
-                case 0x1023: map_key_clear(KEY_CLOSE);          break;
-                case 0x1027: map_key_clear(KEY_MENU);           break;
-                /* this one is marked as 'Rotate' */
-                case 0x1028: map_key_clear(KEY_ANGLE);          break;
-                case 0x1029: map_key_clear(KEY_SHUFFLE);        break;
-                case 0x102a: map_key_clear(KEY_BACK);           break;
-                case 0x102b: map_key_clear(KEY_CYCLEWINDOWS);   break;
-                case 0x1041: map_key_clear(KEY_BATTERY);        break;
-                case 0x1042: map_key_clear(KEY_WORDPROCESSOR);  break;
-                case 0x1043: map_key_clear(KEY_SPREADSHEET);    break;
-                case 0x1044: map_key_clear(KEY_PRESENTATION);   break;
-                case 0x1045: map_key_clear(KEY_UNDO);           break;
-                case 0x1046: map_key_clear(KEY_REDO);           break;
-                case 0x1047: map_key_clear(KEY_PRINT);          break;
-                case 0x1048: map_key_clear(KEY_SAVE);           break;
-                case 0x1049: map_key_clear(KEY_PROG1);          break;
-                case 0x104a: map_key_clear(KEY_PROG2);          break;
-                case 0x104b: map_key_clear(KEY_PROG3);          break;
-                case 0x104c: map_key_clear(KEY_PROG4);          break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_cherry_genius_29e(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-        switch (usage->hid & HID_USAGE) {
-                case 0x156: map_key_clear(KEY_WORDPROCESSOR);   break;
-                case 0x157: map_key_clear(KEY_SPREADSHEET);     break;
-                case 0x158: map_key_clear(KEY_PRESENTATION);    break;
-                case 0x15c: map_key_clear(KEY_STOP);            break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_btc_8193(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-        switch (usage->hid & HID_USAGE) {
-                case 0x230: map_key(BTN_MOUSE);                 break;
-                case 0x231: map_rel(REL_WHEEL);                 break;
-                /* 
-                 * this keyboard has a scrollwheel implemented in
-                 * totally broken way. We map this usage temporarily
-                 * to HWHEEL and handle it in the event quirk handler
-                 */
-                case 0x232: map_rel(REL_HWHEEL);                break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-static int quirk_sunplus_wdesktop(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-        switch (usage->hid & HID_USAGE) {
-                case 0x2003: map_key_clear(KEY_ZOOMIN);         break;
-                case 0x2103: map_key_clear(KEY_ZOOMOUT);        break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-#define VENDOR_ID_BELKIN                        0x1020
-#define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD      0x0006
-#define VENDOR_ID_CHERRY                        0x046a
-#define DEVICE_ID_CHERRY_CYMOTION               0x0023
-#define VENDOR_ID_CHICONY                       0x04f2
-#define DEVICE_ID_CHICONY_TACTICAL_PAD          0x0418
-#define VENDOR_ID_EZKEY                         0x0518
-#define DEVICE_ID_BTC_8193                      0x0002
-#define VENDOR_ID_GYRATION                      0x0c16
-#define DEVICE_ID_GYRATION_REMOTE               0x0002
-#define VENDOR_ID_LOGITECH                      0x046d
-#define DEVICE_ID_LOGITECH_RECEIVER             0xc101
-#define DEVICE_ID_S510_RECEIVER                 0xc50c
-#define DEVICE_ID_S510_RECEIVER_2               0xc517
-#define DEVICE_ID_MX3000_RECEIVER               0xc513
-#define VENDOR_ID_MICROSOFT                     0x045e
-#define DEVICE_ID_MS4K                          0x00db
-#define DEVICE_ID_MS6K                          0x00f9
-#define DEVICE_IS_MS_PRESENTER_8K_BT            0x0701
-#define DEVICE_ID_MS_PRESENTER_8K_USB           0x0713
-#define VENDOR_ID_MONTEREY                      0x0566
-#define DEVICE_ID_GENIUS_KB29E                  0x3004
-#define VENDOR_ID_PETALYNX                      0x18b1
-#define DEVICE_ID_PETALYNX_MAXTER_REMOTE        0x0037
-#define VENDOR_ID_SUNPLUS                       0x04fc
-#define DEVICE_ID_SUNPLUS_WDESKTOP              0x05d8
-static const struct hid_input_blacklist {
-        __u16 idVendor;
-        __u16 idProduct;
-        int (*quirk)(struct hid_usage *, struct input_dev *, unsigned long **, int *);
-} hid_input_blacklist[] = {
-        { VENDOR_ID_BELKIN, DEVICE_ID_BELKIN_WIRELESS_KEYBOARD, quirk_belkin_wkbd },
-        { VENDOR_ID_CHERRY, DEVICE_ID_CHERRY_CYMOTION, quirk_cherry_cymotion },
-        { VENDOR_ID_CHICONY, DEVICE_ID_CHICONY_TACTICAL_PAD, quirk_chicony_tactical_pad },
-        { VENDOR_ID_EZKEY, DEVICE_ID_BTC_8193, quirk_btc_8193 },
-        { VENDOR_ID_GYRATION, DEVICE_ID_GYRATION_REMOTE, quirk_gyration_remote },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_LOGITECH_RECEIVER, quirk_logitech_ultrax_remote },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER, quirk_logitech_wireless },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER_2, quirk_logitech_wireless },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_MX3000_RECEIVER, quirk_logitech_wireless },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS4K, quirk_microsoft_ergonomy_kb },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS6K, quirk_microsoft_ergonomy_kb },
-        { VENDOR_ID_MICROSOFT, DEVICE_IS_MS_PRESENTER_8K_BT, quirk_microsoft_presenter_8k },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS_PRESENTER_8K_USB, quirk_microsoft_presenter_8k },
-        { VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e },
-        { VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote },
-        { VENDOR_ID_SUNPLUS, DEVICE_ID_SUNPLUS_WDESKTOP, quirk_sunplus_wdesktop },
-        { 0, 0, NULL }
-};
-int hidinput_mapping_quirks(struct hid_usage *usage, 
-                                   struct input_dev *input, 
-                                   unsigned long **bit, int *max)
-{
-        struct hid_device *device = input_get_drvdata(input);
-        int i = 0;
-        
-        while (hid_input_blacklist[i].quirk) {
-                if (hid_input_blacklist[i].idVendor == device->vendor &&
-                                hid_input_blacklist[i].idProduct == device->product)
-                        return hid_input_blacklist[i].quirk(usage, input, bit, max);
-                i++;
-        }
-        return 0;
-}
-int hidinput_event_quirks(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
-{
-        struct input_dev *input;
-        input = field->hidinput->input;
-        if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
-                || ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
-                if (value) hid->quirks |=  HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
-                else       hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
-                return 1;
-        }
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
-                        (usage->type == EV_REL) &&
-                        (usage->code == REL_WHEEL)) {
-                hid->delayed_value = value;
-                return 1;
-        }
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
-                        (usage->hid == 0x000100b8)) {
-                input_event(input, EV_REL, value ? REL_HWHEEL : REL_WHEEL, hid->delayed_value);
-                return 1;
-        }
-        if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
-                input_event(input, usage->type, usage->code, -value);
-                return 1;
-        }
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
-                input_event(input, usage->type, REL_HWHEEL, value);
-                return 1;
-        }
-        if ((hid->quirks & HID_QUIRK_APPLE_HAS_FN) && hidinput_apple_event(hid, input, usage, value))
-                return 1;
-        /* Handling MS keyboards special buttons */
-        if (hid->quirks & HID_QUIRK_MICROSOFT_KEYS && 
-                        usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
-                int key = 0;
-                static int last_key = 0;
-                switch (value) {
-                        case 0x01: key = KEY_F14; break;
-                        case 0x02: key = KEY_F15; break;
-                        case 0x04: key = KEY_F16; break;
-                        case 0x08: key = KEY_F17; break;
-                        case 0x10: key = KEY_F18; break;
-                        default: break;
-                }
-                if (key) {
-                        input_event(input, usage->type, key, 1);
-                        last_key = key;
-                } else {
-                        input_event(input, usage->type, last_key, 0);
-                }
-        }
-        /* handle the temporary quirky mapping to HWHEEL */
-        if (hid->quirks & HID_QUIRK_HWHEEL_WHEEL_INVERT &&
-                        usage->type == EV_REL && usage->code == REL_HWHEEL) {
-                input_event(input, usage->type, REL_WHEEL, -value);
-                return 1;
-        }
-        /* Gyration MCE remote "Sleep" key */
-        if (hid->vendor == VENDOR_ID_GYRATION &&
-            hid->product == DEVICE_ID_GYRATION_REMOTE &&
-            (usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
-            (usage->hid & 0xff) == 0x82) {
-                input_event(input, usage->type, usage->code, 1);
-                input_sync(input);
-                input_event(input, usage->type, usage->code, 0);
-                input_sync(input);
-                return 1;
-        }
-        return 0;
-}
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 1b2e8dc3398d..7f183b7147e1 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -32,11 +32,6 @@
 #include <linux/hid.h>
 #include <linux/hid-debug.h>
-static int hid_apple_fnmode = 1;
-module_param_named(pb_fnmode, hid_apple_fnmode, int, 0644);
-MODULE_PARM_DESC(pb_fnmode,
-                "Mode of fn key on Apple keyboards (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
 #define unk     KEY_UNKNOWN
 static const unsigned char hid_keyboard[256] = {
@@ -58,227 +53,20 @@ static const unsigned char hid_keyboard[256] = {
        150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
 };
-/* extended mapping for certain Logitech hardware (Logitech cordless desktop LX500) */
-#define LOGITECH_EXPANDED_KEYMAP_SIZE 80
-static int logitech_expanded_keymap[LOGITECH_EXPANDED_KEYMAP_SIZE] = {
-          0,216,  0,213,175,156,  0,  0,  0,  0,
-        144,  0,  0,  0,  0,  0,  0,  0,  0,212,
-        174,167,152,161,112,  0,  0,  0,154,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,183,184,185,186,187,
-        188,189,190,191,192,193,194,  0,  0,  0
-};
 static const struct {
        __s32 x;
        __s32 y;
 }  hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
-#define map_abs(c)      do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
+#define map_abs(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
-#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
+#define map_rel(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_REL, (c))
-#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
+#define map_key(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_KEY, (c))
-#define map_led(c)      do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
+#define map_led(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
-#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, bit); } while (0)
-#define map_key_clear(c)        do { map_key(c); clear_bit(c, bit); } while (0)
-#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
-struct hidinput_key_translation {
-        u16 from;
-        u16 to;
-        u8 flags;
-};
-#define APPLE_FLAG_FKEY 0x01
-static struct hidinput_key_translation apple_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
-        { KEY_F3,       KEY_FN_F5,          APPLE_FLAG_FKEY }, /* Expos� */
-        { KEY_F4,       KEY_FN_F4,          APPLE_FLAG_FKEY }, /* Dashboard */
-        { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
-        { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
-        { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
-        { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
-        { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
-        { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
-        { KEY_UP,       KEY_PAGEUP },
-        { KEY_DOWN,     KEY_PAGEDOWN },
-        { KEY_LEFT,     KEY_HOME },
-        { KEY_RIGHT,    KEY_END },
-        { }
-};
-static struct hidinput_key_translation powerbook_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
-        { KEY_F3,       KEY_MUTE,               APPLE_FLAG_FKEY },
-        { KEY_F4,       KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
-        { KEY_F5,       KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_NUMLOCK,            APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
-        { KEY_F8,       KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
-        { KEY_F9,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
-        { KEY_F10,      KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
-        { KEY_UP,       KEY_PAGEUP },
-        { KEY_DOWN,     KEY_PAGEDOWN },
-        { KEY_LEFT,     KEY_HOME },
-        { KEY_RIGHT,    KEY_END },
-        { }
-};
-static struct hidinput_key_translation powerbook_numlock_keys[] = {
-        { KEY_J,        KEY_KP1 },
-        { KEY_K,        KEY_KP2 },
-        { KEY_L,        KEY_KP3 },
-        { KEY_U,        KEY_KP4 },
-        { KEY_I,        KEY_KP5 },
-        { KEY_O,        KEY_KP6 },
-        { KEY_7,        KEY_KP7 },
-        { KEY_8,        KEY_KP8 },
-        { KEY_9,        KEY_KP9 },
-        { KEY_M,        KEY_KP0 },
-        { KEY_DOT,      KEY_KPDOT },
-        { KEY_SLASH,    KEY_KPPLUS },
-        { KEY_SEMICOLON, KEY_KPMINUS },
-        { KEY_P,        KEY_KPASTERISK },
-        { KEY_MINUS,    KEY_KPEQUAL },
-        { KEY_0,        KEY_KPSLASH },
-        { KEY_F6,       KEY_NUMLOCK },
-        { KEY_KPENTER,  KEY_KPENTER },
-        { KEY_BACKSPACE, KEY_BACKSPACE },
-        { }
-};
-static struct hidinput_key_translation apple_iso_keyboard[] = {
-        { KEY_GRAVE,    KEY_102ND },
-        { KEY_102ND,    KEY_GRAVE },
-        { }
-};
-static struct hidinput_key_translation *find_translation(struct hidinput_key_translation *table, u16 from)
+#define map_abs_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
-{
+                &max, EV_ABS, (c))
-        struct hidinput_key_translation *trans;
+#define map_key_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
+                &max, EV_KEY, (c))
-        /* Look for the translation */
-        for (trans = table; trans->from; trans++)
-                if (trans->from == from)
-                        return trans;
-        return NULL;
-}
-int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
-                struct hid_usage *usage, __s32 value)
-{
-        struct hidinput_key_translation *trans;
-        if (usage->code == KEY_FN) {
-                if (value) hid->quirks |=  HID_QUIRK_APPLE_FN_ON;
-                else       hid->quirks &= ~HID_QUIRK_APPLE_FN_ON;
-                input_event(input, usage->type, usage->code, value);
-                return 1;
-        }
-        if (hid_apple_fnmode) {
-                int do_translate;
-                trans = find_translation((hid->product < 0x220 ||
-                                          hid->product >= 0x300) ?
-                                         powerbook_fn_keys : apple_fn_keys,
-                                         usage->code);
-                if (trans) {
-                        if (test_bit(usage->code, hid->apple_pressed_fn))
-                                do_translate = 1;
-                        else if (trans->flags & APPLE_FLAG_FKEY)
-                                do_translate =
-                                        (hid_apple_fnmode == 2 &&  (hid->quirks & HID_QUIRK_APPLE_FN_ON)) ||
-                                        (hid_apple_fnmode == 1 && !(hid->quirks & HID_QUIRK_APPLE_FN_ON));
-                        else
-                                do_translate = (hid->quirks & HID_QUIRK_APPLE_FN_ON);
-                        if (do_translate) {
-                                if (value)
-                                        set_bit(usage->code, hid->apple_pressed_fn);
-                                else
-                                        clear_bit(usage->code, hid->apple_pressed_fn);
-                                input_event(input, usage->type, trans->to, value);
-                                return 1;
-                        }
-                }
-                if (hid->quirks & HID_QUIRK_APPLE_NUMLOCK_EMULATION && (
-                                test_bit(usage->code, hid->pb_pressed_numlock) ||
-                                test_bit(LED_NUML, input->led))) {
-                        trans = find_translation(powerbook_numlock_keys, usage->code);
-                        if (trans) {
-                                if (value)
-                                        set_bit(usage->code, hid->pb_pressed_numlock);
-                                else
-                                        clear_bit(usage->code, hid->pb_pressed_numlock);
-                                input_event(input, usage->type, trans->to, value);
-                        }
-                        return 1;
-                }
-        }
-        if (hid->quirks & HID_QUIRK_APPLE_ISO_KEYBOARD) {
-                trans = find_translation(apple_iso_keyboard, usage->code);
-                if (trans) {
-                        input_event(input, usage->type, trans->to, value);
-                        return 1;
-                }
-        }
-        return 0;
-}
-static void hidinput_apple_setup(struct input_dev *input)
-{
-        struct hidinput_key_translation *trans;
-        set_bit(KEY_NUMLOCK, input->keybit);
-        /* Enable all needed keys */
-        for (trans = apple_fn_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-        for (trans = powerbook_fn_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-        for (trans = powerbook_numlock_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-        for (trans = apple_iso_keyboard; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-}
-#else
-inline int hidinput_apple_event(struct hid_device *hid,
-                                       struct input_dev *input,
-                                       struct hid_usage *usage, __s32 value)
-{
-        return 0;
-}
-static inline void hidinput_apple_setup(struct input_dev *input)
-{
-}
-#endif
 static inline int match_scancode(int code, int scancode)
 {
@@ -366,7 +154,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 {
        struct input_dev *input = hidinput->input;
        struct hid_device *device = input_get_drvdata(input);
-        int max = 0, code, ret;
+        int max = 0, code;
        unsigned long *bit = NULL;
        field->hidinput = hidinput;
@@ -385,406 +173,345 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                goto ignore;
        }
-        /* handle input mappings for quirky devices */
+        if (device->driver->input_mapping) {
-        ret = hidinput_mapping_quirks(usage, input, &bit, &max);
+                int ret = device->driver->input_mapping(device, hidinput, field,
-        if (ret)
+                                usage, &bit, &max);
-                goto mapped;
+                if (ret > 0)
+                        goto mapped;
+                if (ret < 0)
+                        goto ignore;
+        }
        switch (usage->hid & HID_USAGE_PAGE) {
+        case HID_UP_UNDEFINED:
+                goto ignore;
-                case HID_UP_UNDEFINED:
+        case HID_UP_KEYBOARD:
-                        goto ignore;
+                set_bit(EV_REP, input->evbit);
-                case HID_UP_KEYBOARD:
-                        set_bit(EV_REP, input->evbit);
+                if ((usage->hid & HID_USAGE) < 256) {
+                        if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
+                        map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
+                } else
+                        map_key(KEY_UNKNOWN);
-                        if ((usage->hid & HID_USAGE) < 256) {
+                break;
-                                if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
-                                map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
-                        } else
-                                map_key(KEY_UNKNOWN);
-                        break;
+        case HID_UP_BUTTON:
+                code = ((usage->hid - 1) & 0xf);
-                case HID_UP_BUTTON:
+                switch (field->application) {
+                case HID_GD_MOUSE:
-                        code = ((usage->hid - 1) & 0xf);
+                case HID_GD_POINTER:  code += 0x110; break;
+                case HID_GD_JOYSTICK: code += 0x120; break;
-                        switch (field->application) {
+                case HID_GD_GAMEPAD:  code += 0x130; break;
-                                case HID_GD_MOUSE:
+                default:
-                                case HID_GD_POINTER:  code += 0x110; break;
+                        switch (field->physical) {
-                                case HID_GD_JOYSTICK: code += 0x120; break;
+                        case HID_GD_MOUSE:
-                                case HID_GD_GAMEPAD:  code += 0x130; break;
+                        case HID_GD_POINTER:  code += 0x110; break;
-                                default:
+                        case HID_GD_JOYSTICK: code += 0x120; break;
-                                        switch (field->physical) {
+                        case HID_GD_GAMEPAD:  code += 0x130; break;
-                                                case HID_GD_MOUSE:
+                        default:              code += 0x100;
-                                                case HID_GD_POINTER:  code += 0x110; break;
-                                                case HID_GD_JOYSTICK: code += 0x120; break;
-                                                case HID_GD_GAMEPAD:  code += 0x130; break;
-                                                default:              code += 0x100;
-                                        }
-                        }
-                        /* Special handling for Logitech Cordless Desktop */
-                        if (field->application != HID_GD_MOUSE) {
-                                if (device->quirks & HID_QUIRK_LOGITECH_EXPANDED_KEYMAP) {
-                                        int hid = usage->hid & HID_USAGE;
-                                        if (hid < LOGITECH_EXPANDED_KEYMAP_SIZE && logitech_expanded_keymap[hid] != 0)
-                                                code = logitech_expanded_keymap[hid];
-                                }
-                        } else {
-                                if (device->quirks & HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL) {
-                                        int hid = usage->hid & HID_USAGE;
-                                        if (hid == 7 || hid == 8)
-                                                goto ignore;
-                                }
                        }
+                }
-                        map_key(code);
+                map_key(code);
-                        break;
+                break;
+        case HID_UP_SIMULATION:
-                case HID_UP_SIMULATION:
+                switch (usage->hid & 0xffff) {
+                case 0xba: map_abs(ABS_RUDDER);   break;
-                        switch (usage->hid & 0xffff) {
+                case 0xbb: map_abs(ABS_THROTTLE); break;
-                                case 0xba: map_abs(ABS_RUDDER);   break;
+                case 0xc4: map_abs(ABS_GAS);      break;
-                                case 0xbb: map_abs(ABS_THROTTLE); break;
+                case 0xc5: map_abs(ABS_BRAKE);    break;
-                                case 0xc4: map_abs(ABS_GAS);      break;
+                case 0xc8: map_abs(ABS_WHEEL);    break;
-                                case 0xc5: map_abs(ABS_BRAKE);    break;
+                default:   goto ignore;
-                                case 0xc8: map_abs(ABS_WHEEL);    break;
+                }
-                                default:   goto ignore;
+                break;
+        case HID_UP_GENDESK:
+                if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
+                        switch (usage->hid & 0xf) {
+                        case 0x1: map_key_clear(KEY_POWER);  break;
+                        case 0x2: map_key_clear(KEY_SLEEP);  break;
+                        case 0x3: map_key_clear(KEY_WAKEUP); break;
+                        default: goto unknown;
                        }
                        break;
+                }
-                case HID_UP_GENDESK:
+                if ((usage->hid & 0xf0) == 0x90) {      /* D-pad */
-                        if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
-                                switch (usage->hid & 0xf) {
-                                        case 0x1: map_key_clear(KEY_POWER);  break;
-                                        case 0x2: map_key_clear(KEY_SLEEP);  break;
-                                        case 0x3: map_key_clear(KEY_WAKEUP); break;
-                                        default: goto unknown;
-                                }
-                                break;
-                        }
-                        if ((usage->hid & 0xf0) == 0x90) {      /* D-pad */
-                                switch (usage->hid) {
-                                        case HID_GD_UP:    usage->hat_dir = 1; break;
-                                        case HID_GD_DOWN:  usage->hat_dir = 5; break;
-                                        case HID_GD_RIGHT: usage->hat_dir = 3; break;
-                                        case HID_GD_LEFT:  usage->hat_dir = 7; break;
-                                        default: goto unknown;
-                                }
-                                if (field->dpad) {
-                                        map_abs(field->dpad);
-                                        goto ignore;
-                                }
-                                map_abs(ABS_HAT0X);
-                                break;
-                        }
                        switch (usage->hid) {
+                        case HID_GD_UP:    usage->hat_dir = 1; break;
-                                /* These usage IDs map directly to the usage codes. */
+                        case HID_GD_DOWN:  usage->hat_dir = 5; break;
-                                case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
+                        case HID_GD_RIGHT: usage->hat_dir = 3; break;
-                                case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
+                        case HID_GD_LEFT:  usage->hat_dir = 7; break;
-                                case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
+                        default: goto unknown;
-                                        if (field->flags & HID_MAIN_ITEM_RELATIVE)
-                                                map_rel(usage->hid & 0xf);
-                                        else
-                                                map_abs(usage->hid & 0xf);
-                                        break;
-                                case HID_GD_HATSWITCH:
-                                        usage->hat_min = field->logical_minimum;
-                                        usage->hat_max = field->logical_maximum;
-                                        map_abs(ABS_HAT0X);
-                                        break;
-                                case HID_GD_START:      map_key_clear(BTN_START);       break;
-                                case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
-                                default: goto unknown;
                        }
+                        if (field->dpad) {
-                        break;
+                                map_abs(field->dpad);
+                                goto ignore;
-                case HID_UP_LED:
-                        switch (usage->hid & 0xffff) {                        /* HID-Value:                   */
-                                case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
-                                case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
-                                case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
-                                case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
-                                case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
-                                case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
-                                case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
-                                case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
-                                case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
-                                case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
-                                case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
-                                default: goto ignore;
                        }
+                        map_abs(ABS_HAT0X);
                        break;
+                }
-                case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                /* These usage IDs map directly to the usage codes. */
-                        switch (usage->hid & 0xff) {
+                case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
+                case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
-                                case 0x30: /* TipPressure */
+                case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
-                                        if (!test_bit(BTN_TOUCH, input->keybit)) {
+                        if (field->flags & HID_MAIN_ITEM_RELATIVE)
-                                                device->quirks |= HID_QUIRK_NOTOUCH;
+                                map_rel(usage->hid & 0xf);
-                                                set_bit(EV_KEY, input->evbit);
+                        else
-                                                set_bit(BTN_TOUCH, input->keybit);
+                                map_abs(usage->hid & 0xf);
-                                        }
+                        break;
-                                        map_abs_clear(ABS_PRESSURE);
-                                        break;
-                                case 0x32: /* InRange */
-                                        switch (field->physical & 0xff) {
-                                                case 0x21: map_key(BTN_TOOL_MOUSE); break;
-                                                case 0x22: map_key(BTN_TOOL_FINGER); break;
-                                                default: map_key(BTN_TOOL_PEN); break;
-                                        }
-                                        break;
-                                case 0x3c: /* Invert */
+                case HID_GD_HATSWITCH:
-                                        map_key_clear(BTN_TOOL_RUBBER);
+                        usage->hat_min = field->logical_minimum;
-                                        break;
+                        usage->hat_max = field->logical_maximum;
+                        map_abs(ABS_HAT0X);
+                        break;
-                                case 0x33: /* Touch */
+                case HID_GD_START:      map_key_clear(BTN_START);       break;
-                                case 0x42: /* TipSwitch */
+                case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
-                                case 0x43: /* TipSwitch2 */
-                                        device->quirks &= ~HID_QUIRK_NOTOUCH;
-                                        map_key_clear(BTN_TOUCH);
-                                        break;
-                                case 0x44: /* BarrelSwitch */
+                default: goto unknown;
-                                        map_key_clear(BTN_STYLUS);
+                }
-                                        break;
-                                default:  goto unknown;
+                break;
+        case HID_UP_LED:
+                switch (usage->hid & 0xffff) {                /* HID-Value:                   */
+                case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
+                case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
+                case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
+                case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
+                case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
+                case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
+                case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
+                case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
+                case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
+                case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
+                case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
+                default: goto ignore;
+                }
+                break;
+        case HID_UP_DIGITIZER:
+                switch (usage->hid & 0xff) {
+                case 0x30: /* TipPressure */
+                        if (!test_bit(BTN_TOUCH, input->keybit)) {
+                                device->quirks |= HID_QUIRK_NOTOUCH;
+                                set_bit(EV_KEY, input->evbit);
+                                set_bit(BTN_TOUCH, input->keybit);
                        }
+                        map_abs_clear(ABS_PRESSURE);
                        break;
-                case HID_UP_CONSUMER:   /* USB HUT v1.1, pages 56-62 */
+                case 0x32: /* InRange */
+                        switch (field->physical & 0xff) {
-                        switch (usage->hid & HID_USAGE) {
+                        case 0x21: map_key(BTN_TOOL_MOUSE); break;
-                                case 0x000: goto ignore;
+                        case 0x22: map_key(BTN_TOOL_FINGER); break;
-                                case 0x034: map_key_clear(KEY_SLEEP);           break;
+                        default: map_key(BTN_TOOL_PEN); break;
-                                case 0x036: map_key_clear(BTN_MISC);            break;
-                                case 0x040: map_key_clear(KEY_MENU);            break;
-                                case 0x045: map_key_clear(KEY_RADIO);           break;
-                                case 0x083: map_key_clear(KEY_LAST);            break;
-                                case 0x088: map_key_clear(KEY_PC);              break;
-                                case 0x089: map_key_clear(KEY_TV);              break;
-                                case 0x08a: map_key_clear(KEY_WWW);             break;
-                                case 0x08b: map_key_clear(KEY_DVD);             break;
-                                case 0x08c: map_key_clear(KEY_PHONE);           break;
-                                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
-                                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
-                                case 0x08f: map_key_clear(KEY_GAMES);           break;
-                                case 0x090: map_key_clear(KEY_MEMO);            break;
-                                case 0x091: map_key_clear(KEY_CD);              break;
-                                case 0x092: map_key_clear(KEY_VCR);             break;
-                                case 0x093: map_key_clear(KEY_TUNER);           break;
-                                case 0x094: map_key_clear(KEY_EXIT);            break;
-                                case 0x095: map_key_clear(KEY_HELP);            break;
-                                case 0x096: map_key_clear(KEY_TAPE);            break;
-                                case 0x097: map_key_clear(KEY_TV2);             break;
-                                case 0x098: map_key_clear(KEY_SAT);             break;
-                                case 0x09a: map_key_clear(KEY_PVR);             break;
-                                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
-                                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
-                                case 0x0a0: map_key_clear(KEY_VCR2);            break;
-                                case 0x0b0: map_key_clear(KEY_PLAY);            break;
-                                case 0x0b1: map_key_clear(KEY_PAUSE);           break;
-                                case 0x0b2: map_key_clear(KEY_RECORD);          break;
-                                case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
-                                case 0x0b4: map_key_clear(KEY_REWIND);          break;
-                                case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
-                                case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
-                                case 0x0b7: map_key_clear(KEY_STOPCD);          break;
-                                case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
-                                case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
-                                case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
-                                case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
-                                case 0x0e2: map_key_clear(KEY_MUTE);            break;
-                                case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
-                                case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
-                                case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
-                                case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
-                                case 0x183: map_key_clear(KEY_CONFIG);          break;
-                                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
-                                case 0x185: map_key_clear(KEY_EDITOR);          break;
-                                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
-                                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
-                                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
-                                case 0x189: map_key_clear(KEY_DATABASE);        break;
-                                case 0x18a: map_key_clear(KEY_MAIL);            break;
-                                case 0x18b: map_key_clear(KEY_NEWS);            break;
-                                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
-                                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
-                                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
-                                case 0x191: map_key_clear(KEY_FINANCE);         break;
-                                case 0x192: map_key_clear(KEY_CALC);            break;
-                                case 0x194: map_key_clear(KEY_FILE);            break;
-                                case 0x196: map_key_clear(KEY_WWW);             break;
-                                case 0x19c: map_key_clear(KEY_LOGOFF);          break;
-                                case 0x19e: map_key_clear(KEY_COFFEE);          break;
-                                case 0x1a6: map_key_clear(KEY_HELP);            break;
-                                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
-                                case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
-                                case 0x1b6: map_key_clear(KEY_MEDIA);           break;
-                                case 0x1b7: map_key_clear(KEY_SOUND);           break;
-                                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
-                                case 0x1bd: map_key_clear(KEY_INFO);            break;
-                                case 0x201: map_key_clear(KEY_NEW);             break;
-                                case 0x202: map_key_clear(KEY_OPEN);            break;
-                                case 0x203: map_key_clear(KEY_CLOSE);           break;
-                                case 0x204: map_key_clear(KEY_EXIT);            break;
-                                case 0x207: map_key_clear(KEY_SAVE);            break;
-                                case 0x208: map_key_clear(KEY_PRINT);           break;
-                                case 0x209: map_key_clear(KEY_PROPS);           break;
-                                case 0x21a: map_key_clear(KEY_UNDO);            break;
-                                case 0x21b: map_key_clear(KEY_COPY);            break;
-                                case 0x21c: map_key_clear(KEY_CUT);             break;
-                                case 0x21d: map_key_clear(KEY_PASTE);           break;
-                                case 0x21f: map_key_clear(KEY_FIND);            break;
-                                case 0x221: map_key_clear(KEY_SEARCH);          break;
-                                case 0x222: map_key_clear(KEY_GOTO);            break;
-                                case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
-                                case 0x224: map_key_clear(KEY_BACK);            break;
-                                case 0x225: map_key_clear(KEY_FORWARD);         break;
-                                case 0x226: map_key_clear(KEY_STOP);            break;
-                                case 0x227: map_key_clear(KEY_REFRESH);         break;
-                                case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
-                                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
-                                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
-                                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
-                                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
-                                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
-                                case 0x238: map_rel(REL_HWHEEL);                break;
-                                case 0x25f: map_key_clear(KEY_CANCEL);          break;
-                                case 0x279: map_key_clear(KEY_REDO);            break;
-                                case 0x289: map_key_clear(KEY_REPLY);           break;
-                                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
-                                case 0x28c: map_key_clear(KEY_SEND);            break;
-                                default:    goto ignore;
                        }
                        break;
-                case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
+                case 0x3c: /* Invert */
+                        map_key_clear(BTN_TOOL_RUBBER);
-                        set_bit(EV_REP, input->evbit);
-                        switch (usage->hid & HID_USAGE) {
-                                case 0x021: map_key_clear(KEY_PRINT);           break;
-                                case 0x070: map_key_clear(KEY_HP);              break;
-                                case 0x071: map_key_clear(KEY_CAMERA);          break;
-                                case 0x072: map_key_clear(KEY_SOUND);           break;
-                                case 0x073: map_key_clear(KEY_QUESTION);        break;
-                                case 0x080: map_key_clear(KEY_EMAIL);           break;
-                                case 0x081: map_key_clear(KEY_CHAT);            break;
-                                case 0x082: map_key_clear(KEY_SEARCH);          break;
-                                case 0x083: map_key_clear(KEY_CONNECT);         break;
-                                case 0x084: map_key_clear(KEY_FINANCE);         break;
-                                case 0x085: map_key_clear(KEY_SPORT);           break;
-                                case 0x086: map_key_clear(KEY_SHOP);            break;
-                                default:    goto ignore;
-                        }
                        break;
-                case HID_UP_MSVENDOR:
+                case 0x33: /* Touch */
+                case 0x42: /* TipSwitch */
-                        goto ignore;
+                case 0x43: /* TipSwitch2 */
+                        device->quirks &= ~HID_QUIRK_NOTOUCH;
-                case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
+                        map_key_clear(BTN_TOUCH);
+                        break;
-                        set_bit(EV_REP, input->evbit);
-                        switch(usage->hid & HID_USAGE) {
-                                case 0x003:
-                                        /* The fn key on Apple USB keyboards */
-                                        map_key_clear(KEY_FN);
-                                        hidinput_apple_setup(input);
-                                        break;
-                                default:    goto ignore;
+                case 0x44: /* BarrelSwitch */
-                        }
+                        map_key_clear(BTN_STYLUS);
                        break;
-                case HID_UP_LOGIVENDOR:
+                default:  goto unknown;
+                }
+                break;
+        case HID_UP_CONSUMER:   /* USB HUT v1.1, pages 56-62 */
+                switch (usage->hid & HID_USAGE) {
+                case 0x000: goto ignore;
+                case 0x034: map_key_clear(KEY_SLEEP);           break;
+                case 0x036: map_key_clear(BTN_MISC);            break;
+                case 0x040: map_key_clear(KEY_MENU);            break;
+                case 0x045: map_key_clear(KEY_RADIO);           break;
+                case 0x083: map_key_clear(KEY_LAST);            break;
+                case 0x088: map_key_clear(KEY_PC);              break;
+                case 0x089: map_key_clear(KEY_TV);              break;
+                case 0x08a: map_key_clear(KEY_WWW);             break;
+                case 0x08b: map_key_clear(KEY_DVD);             break;
+                case 0x08c: map_key_clear(KEY_PHONE);           break;
+                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
+                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
+                case 0x08f: map_key_clear(KEY_GAMES);           break;
+                case 0x090: map_key_clear(KEY_MEMO);            break;
+                case 0x091: map_key_clear(KEY_CD);              break;
+                case 0x092: map_key_clear(KEY_VCR);             break;
+                case 0x093: map_key_clear(KEY_TUNER);           break;
+                case 0x094: map_key_clear(KEY_EXIT);            break;
+                case 0x095: map_key_clear(KEY_HELP);            break;
+                case 0x096: map_key_clear(KEY_TAPE);            break;
+                case 0x097: map_key_clear(KEY_TV2);             break;
+                case 0x098: map_key_clear(KEY_SAT);             break;
+                case 0x09a: map_key_clear(KEY_PVR);             break;
+                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
+                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
+                case 0x0a0: map_key_clear(KEY_VCR2);            break;
+                case 0x0b0: map_key_clear(KEY_PLAY);            break;
+                case 0x0b1: map_key_clear(KEY_PAUSE);           break;
+                case 0x0b2: map_key_clear(KEY_RECORD);          break;
+                case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
+                case 0x0b4: map_key_clear(KEY_REWIND);          break;
+                case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
+                case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
+                case 0x0b7: map_key_clear(KEY_STOPCD);          break;
+                case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
+                case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
+                case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
+                case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
+                case 0x0e2: map_key_clear(KEY_MUTE);            break;
+                case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
+                case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
+                case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
+                case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
+                case 0x183: map_key_clear(KEY_CONFIG);          break;
+                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
+                case 0x185: map_key_clear(KEY_EDITOR);          break;
+                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
+                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
+                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
+                case 0x189: map_key_clear(KEY_DATABASE);        break;
+                case 0x18a: map_key_clear(KEY_MAIL);            break;
+                case 0x18b: map_key_clear(KEY_NEWS);            break;
+                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
+                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
+                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
+                case 0x191: map_key_clear(KEY_FINANCE);         break;
+                case 0x192: map_key_clear(KEY_CALC);            break;
+                case 0x194: map_key_clear(KEY_FILE);            break;
+                case 0x196: map_key_clear(KEY_WWW);             break;
+                case 0x19c: map_key_clear(KEY_LOGOFF);          break;
+                case 0x19e: map_key_clear(KEY_COFFEE);          break;
+                case 0x1a6: map_key_clear(KEY_HELP);            break;
+                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
+                case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
+                case 0x1b6: map_key_clear(KEY_MEDIA);           break;
+                case 0x1b7: map_key_clear(KEY_SOUND);           break;
+                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
+                case 0x1bd: map_key_clear(KEY_INFO);            break;
+                case 0x201: map_key_clear(KEY_NEW);             break;
+                case 0x202: map_key_clear(KEY_OPEN);            break;
+                case 0x203: map_key_clear(KEY_CLOSE);           break;
+                case 0x204: map_key_clear(KEY_EXIT);            break;
+                case 0x207: map_key_clear(KEY_SAVE);            break;
+                case 0x208: map_key_clear(KEY_PRINT);           break;
+                case 0x209: map_key_clear(KEY_PROPS);           break;
+                case 0x21a: map_key_clear(KEY_UNDO);            break;
+                case 0x21b: map_key_clear(KEY_COPY);            break;
+                case 0x21c: map_key_clear(KEY_CUT);             break;
+                case 0x21d: map_key_clear(KEY_PASTE);           break;
+                case 0x21f: map_key_clear(KEY_FIND);            break;
+                case 0x221: map_key_clear(KEY_SEARCH);          break;
+                case 0x222: map_key_clear(KEY_GOTO);            break;
+                case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
+                case 0x224: map_key_clear(KEY_BACK);            break;
+                case 0x225: map_key_clear(KEY_FORWARD);         break;
+                case 0x226: map_key_clear(KEY_STOP);            break;
+                case 0x227: map_key_clear(KEY_REFRESH);         break;
+                case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
+                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
+                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
+                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
+                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
+                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
+                case 0x238: map_rel(REL_HWHEEL);                break;
+                case 0x25f: map_key_clear(KEY_CANCEL);          break;
+                case 0x279: map_key_clear(KEY_REDO);            break;
+                case 0x289: map_key_clear(KEY_REPLY);           break;
+                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
+                case 0x28c: map_key_clear(KEY_SEND);            break;
+                default:    goto ignore;
+                }
+                break;
+        case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
+                set_bit(EV_REP, input->evbit);
+                switch (usage->hid & HID_USAGE) {
+                case 0x021: map_key_clear(KEY_PRINT);           break;
+                case 0x070: map_key_clear(KEY_HP);              break;
+                case 0x071: map_key_clear(KEY_CAMERA);          break;
+                case 0x072: map_key_clear(KEY_SOUND);           break;
+                case 0x073: map_key_clear(KEY_QUESTION);        break;
+                case 0x080: map_key_clear(KEY_EMAIL);           break;
+                case 0x081: map_key_clear(KEY_CHAT);            break;
+                case 0x082: map_key_clear(KEY_SEARCH);          break;
+                case 0x083: map_key_clear(KEY_CONNECT);         break;
+                case 0x084: map_key_clear(KEY_FINANCE);         break;
+                case 0x085: map_key_clear(KEY_SPORT);           break;
+                case 0x086: map_key_clear(KEY_SHOP);            break;
+                default:    goto ignore;
+                }
+                break;
-                        goto ignore;
+        case HID_UP_MSVENDOR:
-                
+                goto ignore;
-                case HID_UP_PID:
-                        switch(usage->hid & HID_USAGE) {
+        case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
-                                case 0xa4: map_key_clear(BTN_DEAD);     break;
+                set_bit(EV_REP, input->evbit);
-                                default: goto ignore;
+                goto ignore;
-                        }
-                        break;
-                default:
+        case HID_UP_LOGIVENDOR:
-                unknown:
+                goto ignore;
-                        if (field->report_size == 1) {
+        
-                                if (field->report->type == HID_OUTPUT_REPORT) {
+        case HID_UP_PID:
-                                        map_led(LED_MISC);
+                switch (usage->hid & HID_USAGE) {
-                                        break;
+                case 0xa4: map_key_clear(BTN_DEAD);     break;
-                                }
+                default: goto ignore;
-                                map_key(BTN_MISC);
+                }
-                                break;
+                break;
-                        }
-                        if (field->flags & HID_MAIN_ITEM_RELATIVE) {
+        default:
-                                map_rel(REL_MISC);
+        unknown:
+                if (field->report_size == 1) {
+                        if (field->report->type == HID_OUTPUT_REPORT) {
+                                map_led(LED_MISC);
                                break;
                        }
-                        map_abs(ABS_MISC);
+                        map_key(BTN_MISC);
+                        break;
+                }
+                if (field->flags & HID_MAIN_ITEM_RELATIVE) {
+                        map_rel(REL_MISC);
                        break;
+                }
+                map_abs(ABS_MISC);
+                break;
        }
 mapped:
-        if (device->quirks & HID_QUIRK_MIGHTYMOUSE) {
+        if (device->driver->input_mapped && device->driver->input_mapped(device,
-                if (usage->hid == HID_GD_Z)
+                                hidinput, field, usage, &bit, &max) < 0)
-                        map_rel(REL_HWHEEL);
-                else if (usage->code == BTN_1)
-                        map_key(BTN_2);
-                else if (usage->code == BTN_2)
-                        map_key(BTN_1);
-        }
-        if ((device->quirks & (HID_QUIRK_2WHEEL_MOUSE_HACK_7 | HID_QUIRK_2WHEEL_MOUSE_HACK_5 |
-                        HID_QUIRK_2WHEEL_MOUSE_HACK_B8)) && (usage->type == EV_REL) &&
-                        (usage->code == REL_WHEEL))
-                set_bit(REL_HWHEEL, bit);
-        if (((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
-                || ((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007)))
                goto ignore;
-        if ((device->quirks & HID_QUIRK_BAD_RELATIVE_KEYS) &&
-                usage->type == EV_KEY && (field->flags & HID_MAIN_ITEM_RELATIVE))
-                field->flags &= ~HID_MAIN_ITEM_RELATIVE;
        set_bit(usage->type, input->evbit);
-        if (device->quirks & HID_QUIRK_DUPLICATE_USAGES &&
-                        (usage->type == EV_KEY ||
-                         usage->type == EV_REL ||
-                         usage->type == EV_ABS))
-                clear_bit(usage->code, bit);
        while (usage->code <= max && test_and_set_bit(usage->code, bit))
                usage->code = find_next_zero_bit(bit, max + 1, usage->code);
@@ -858,10 +585,6 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
        if (!usage->type)
                return;
-        /* handle input events for quirky devices */
-        if (hidinput_event_quirks(hid, field, usage, value))
-                return;
        if (usage->hat_min < usage->hat_max || usage->hat_dir) {
                int hat_dir = usage->hat_dir;
                if (!hat_dir)
@@ -961,14 +684,14 @@ static int hidinput_open(struct input_dev *dev)
 {
        struct hid_device *hid = input_get_drvdata(dev);
-        return hid->hid_open(hid);
+        return hid->ll_driver->open(hid);
 }
 static void hidinput_close(struct input_dev *dev)
 {
        struct hid_device *hid = input_get_drvdata(dev);
-        hid->hid_close(hid);
+        hid->ll_driver->close(hid);
 }
 /*
@@ -977,7 +700,7 @@ static void hidinput_close(struct input_dev *dev)
 * Read all reports and initialize the absolute field values.
 */
-int hidinput_connect(struct hid_device *hid)
+int hidinput_connect(struct hid_device *hid, unsigned int force)
 {
        struct hid_report *report;
        struct hid_input *hidinput = NULL;
@@ -985,19 +708,20 @@ int hidinput_connect(struct hid_device *hid)
        int i, j, k;
        int max_report_type = HID_OUTPUT_REPORT;
-        if (hid->quirks & HID_QUIRK_IGNORE_HIDINPUT)
-                return -1;
        INIT_LIST_HEAD(&hid->inputs);
-        for (i = 0; i < hid->maxcollection; i++)
+        if (!force) {
-                if (hid->collection[i].type == HID_COLLECTION_APPLICATION ||
+                for (i = 0; i < hid->maxcollection; i++) {
-                    hid->collection[i].type == HID_COLLECTION_PHYSICAL)
+                        struct hid_collection *col = &hid->collection[i];
-                        if (IS_INPUT_APPLICATION(hid->collection[i].usage))
+                        if (col->type == HID_COLLECTION_APPLICATION ||
-                                break;
+                                        col->type == HID_COLLECTION_PHYSICAL)
+                                if (IS_INPUT_APPLICATION(col->usage))
+                                        break;
+                }
-        if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDINPUT) == 0)
+                if (i == hid->maxcollection)
-                return -1;
+                        return -1;
+        }
        if (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
                max_report_type = HID_INPUT_REPORT;
@@ -1019,7 +743,8 @@ int hidinput_connect(struct hid_device *hid)
                                }
                                input_set_drvdata(input_dev, hid);
-                                input_dev->event = hid->hidinput_input_event;
+                                input_dev->event =
+                                        hid->ll_driver->hidinput_input_event;
                                input_dev->open = hidinput_open;
                                input_dev->close = hidinput_close;
                                input_dev->setkeycode = hidinput_setkeycode;
@@ -1032,7 +757,7 @@ int hidinput_connect(struct hid_device *hid)
                                input_dev->id.vendor  = hid->vendor;
                                input_dev->id.product = hid->product;
                                input_dev->id.version = hid->version;
-                                input_dev->dev.parent = hid->dev;
+                                input_dev->dev.parent = hid->dev.parent;
                                hidinput->input = input_dev;
                                list_add_tail(&hidinput->list, &hid->inputs);
                        }
diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
new file mode 100644
index 000000000000..406d8c82abf1
--- /dev/null
+++ b/drivers/hid/hid-lg.c
@@ -0,0 +1,342 @@
+/*
+ *  HID driver for some logitech "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#include "hid-lg.h"
+#define LG_RDESC                0x001
+#define LG_BAD_RELATIVE_KEYS    0x002
+#define LG_DUPLICATE_USAGES     0x004
+#define LG_RESET_LEDS           0x008
+#define LG_EXPANDED_KEYMAP      0x010
+#define LG_IGNORE_DOUBLED_WHEEL 0x020
+#define LG_WIRELESS             0x040
+#define LG_INVERT_HWHEEL        0x080
+#define LG_NOGET                0x100
+#define LG_FF                   0x200
+#define LG_FF2                  0x400
+/*
+ * Certain Logitech keyboards send in report #3 keys which are far
+ * above the logical maximum described in descriptor. This extends
+ * the original value of 0x28c of logical maximum to 0x104d
+ */
+static void lg_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if ((quirks & LG_RDESC) && rsize >= 90 && rdesc[83] == 0x26 &&
+                        rdesc[84] == 0x8c && rdesc[85] == 0x02) {
+                dev_info(&hdev->dev, "fixing up Logitech keyboard report "
+                                "descriptor\n");
+                rdesc[84] = rdesc[89] = 0x4d;
+                rdesc[85] = rdesc[90] = 0x10;
+        }
+}
+#define lg_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                EV_KEY, (c))
+static int lg_ultrax_remote_mapping(struct hid_input *hi,
+                struct hid_usage *usage, unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
+                return 0;
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        /* Reported on Logitech Ultra X Media Remote */
+        case 0x004: lg_map_key_clear(KEY_AGAIN);        break;
+        case 0x00d: lg_map_key_clear(KEY_HOME);         break;
+        case 0x024: lg_map_key_clear(KEY_SHUFFLE);      break;
+        case 0x025: lg_map_key_clear(KEY_TV);           break;
+        case 0x026: lg_map_key_clear(KEY_MENU);         break;
+        case 0x031: lg_map_key_clear(KEY_AUDIO);        break;
+        case 0x032: lg_map_key_clear(KEY_TEXT);         break;
+        case 0x033: lg_map_key_clear(KEY_LAST);         break;
+        case 0x047: lg_map_key_clear(KEY_MP3);          break;
+        case 0x048: lg_map_key_clear(KEY_DVD);          break;
+        case 0x049: lg_map_key_clear(KEY_MEDIA);        break;
+        case 0x04a: lg_map_key_clear(KEY_VIDEO);        break;
+        case 0x04b: lg_map_key_clear(KEY_ANGLE);        break;
+        case 0x04c: lg_map_key_clear(KEY_LANGUAGE);     break;
+        case 0x04d: lg_map_key_clear(KEY_SUBTITLE);     break;
+        case 0x051: lg_map_key_clear(KEY_RED);          break;
+        case 0x052: lg_map_key_clear(KEY_CLOSE);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int lg_wireless_mapping(struct hid_input *hi, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+        switch (usage->hid & HID_USAGE) {
+        case 0x1001: lg_map_key_clear(KEY_MESSENGER);           break;
+        case 0x1003: lg_map_key_clear(KEY_SOUND);               break;
+        case 0x1004: lg_map_key_clear(KEY_VIDEO);               break;
+        case 0x1005: lg_map_key_clear(KEY_AUDIO);               break;
+        case 0x100a: lg_map_key_clear(KEY_DOCUMENTS);           break;
+        case 0x1011: lg_map_key_clear(KEY_PREVIOUSSONG);        break;
+        case 0x1012: lg_map_key_clear(KEY_NEXTSONG);            break;
+        case 0x1013: lg_map_key_clear(KEY_CAMERA);              break;
+        case 0x1014: lg_map_key_clear(KEY_MESSENGER);           break;
+        case 0x1015: lg_map_key_clear(KEY_RECORD);              break;
+        case 0x1016: lg_map_key_clear(KEY_PLAYER);              break;
+        case 0x1017: lg_map_key_clear(KEY_EJECTCD);             break;
+        case 0x1018: lg_map_key_clear(KEY_MEDIA);               break;
+        case 0x1019: lg_map_key_clear(KEY_PROG1);               break;
+        case 0x101a: lg_map_key_clear(KEY_PROG2);               break;
+        case 0x101b: lg_map_key_clear(KEY_PROG3);               break;
+        case 0x101f: lg_map_key_clear(KEY_ZOOMIN);              break;
+        case 0x1020: lg_map_key_clear(KEY_ZOOMOUT);             break;
+        case 0x1021: lg_map_key_clear(KEY_ZOOMRESET);           break;
+        case 0x1023: lg_map_key_clear(KEY_CLOSE);               break;
+        case 0x1027: lg_map_key_clear(KEY_MENU);                break;
+        /* this one is marked as 'Rotate' */
+        case 0x1028: lg_map_key_clear(KEY_ANGLE);               break;
+        case 0x1029: lg_map_key_clear(KEY_SHUFFLE);             break;
+        case 0x102a: lg_map_key_clear(KEY_BACK);                break;
+        case 0x102b: lg_map_key_clear(KEY_CYCLEWINDOWS);        break;
+        case 0x1041: lg_map_key_clear(KEY_BATTERY);             break;
+        case 0x1042: lg_map_key_clear(KEY_WORDPROCESSOR);       break;
+        case 0x1043: lg_map_key_clear(KEY_SPREADSHEET);         break;
+        case 0x1044: lg_map_key_clear(KEY_PRESENTATION);        break;
+        case 0x1045: lg_map_key_clear(KEY_UNDO);                break;
+        case 0x1046: lg_map_key_clear(KEY_REDO);                break;
+        case 0x1047: lg_map_key_clear(KEY_PRINT);               break;
+        case 0x1048: lg_map_key_clear(KEY_SAVE);                break;
+        case 0x1049: lg_map_key_clear(KEY_PROG1);               break;
+        case 0x104a: lg_map_key_clear(KEY_PROG2);               break;
+        case 0x104b: lg_map_key_clear(KEY_PROG3);               break;
+        case 0x104c: lg_map_key_clear(KEY_PROG4);               break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int lg_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        /* extended mapping for certain Logitech hardware (Logitech cordless
+           desktop LX500) */
+        static const u8 e_keymap[] = {
+                  0,216,  0,213,175,156,  0,  0,  0,  0,
+                144,  0,  0,  0,  0,  0,  0,  0,  0,212,
+                174,167,152,161,112,  0,  0,  0,154,  0,
+                  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                  0,  0,  0,  0,  0,183,184,185,186,187,
+                188,189,190,191,192,193,194,  0,  0,  0
+        };
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        unsigned int hid = usage->hid;
+        if (hdev->product == USB_DEVICE_ID_LOGITECH_RECEIVER &&
+                        lg_ultrax_remote_mapping(hi, usage, bit, max))
+                return 1;
+        if ((quirks & LG_WIRELESS) && lg_wireless_mapping(hi, usage, bit, max))
+                return 1;
+        if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
+                return 0;
+        hid &= HID_USAGE;
+        /* Special handling for Logitech Cordless Desktop */
+        if (field->application == HID_GD_MOUSE) {
+                if ((quirks & LG_IGNORE_DOUBLED_WHEEL) &&
+                                (hid == 7 || hid == 8))
+                        return -1;
+        } else {
+                if ((quirks & LG_EXPANDED_KEYMAP) &&
+                                hid < ARRAY_SIZE(e_keymap) &&
+                                e_keymap[hid] != 0) {
+                        hid_map_usage(hi, usage, bit, max, EV_KEY,
+                                        e_keymap[hid]);
+                        return 1;
+                }
+        }
+        return 0;
+}
+static int lg_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if ((quirks & LG_BAD_RELATIVE_KEYS) && usage->type == EV_KEY &&
+                        (field->flags & HID_MAIN_ITEM_RELATIVE))
+                field->flags &= ~HID_MAIN_ITEM_RELATIVE;
+        if ((quirks & LG_DUPLICATE_USAGES) && (usage->type == EV_KEY ||
+                         usage->type == EV_REL || usage->type == EV_ABS))
+                clear_bit(usage->code, *bit);
+        return 0;
+}
+static int lg_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if ((quirks & LG_INVERT_HWHEEL) && usage->code == REL_HWHEEL) {
+                input_event(field->hidinput->input, usage->type, usage->code,
+                                -value);
+                return 1;
+        }
+        return 0;
+}
+static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        unsigned int connect_mask = HID_CONNECT_DEFAULT;
+        int ret;
+        hid_set_drvdata(hdev, (void *)quirks);
+        if (quirks & LG_NOGET)
+                hdev->quirks |= HID_QUIRK_NOGET;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        if (quirks & (LG_FF | LG_FF2))
+                connect_mask &= ~HID_CONNECT_FF;
+        ret = hid_hw_start(hdev, connect_mask);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        if (quirks & LG_RESET_LEDS)
+                usbhid_set_leds(hdev);
+        if (quirks & LG_FF)
+                lgff_init(hdev);
+        if (quirks & LG_FF2)
+                lg2ff_init(hdev);
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id lg_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
+                .driver_data = LG_RDESC | LG_WIRELESS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
+                .driver_data = LG_RDESC | LG_WIRELESS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
+                .driver_data = LG_RDESC | LG_WIRELESS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
+                .driver_data = LG_BAD_RELATIVE_KEYS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP),
+                .driver_data = LG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE),
+                .driver_data = LG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI),
+                .driver_data = LG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD),
+                .driver_data = LG_RESET_LEDS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD),
+                .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500),
+                .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_LX3),
+                .driver_data = LG_INVERT_HWHEEL },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150),
+                .driver_data = LG_INVERT_HWHEEL },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
+                .driver_data = LG_NOGET },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
+                .driver_data = LG_NOGET | LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
+                .driver_data = LG_FF2 },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, lg_devices);
+static struct hid_driver lg_driver = {
+        .name = "logitech",
+        .id_table = lg_devices,
+        .report_fixup = lg_report_fixup,
+        .input_mapping = lg_input_mapping,
+        .input_mapped = lg_input_mapped,
+        .event = lg_event,
+        .probe = lg_probe,
+};
+static int lg_init(void)
+{
+        return hid_register_driver(&lg_driver);
+}
+static void lg_exit(void)
+{
+        hid_unregister_driver(&lg_driver);
+}
+module_init(lg_init);
+module_exit(lg_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(logitech);
diff --git a/drivers/hid/hid-lg.h b/drivers/hid/hid-lg.h
new file mode 100644
index 000000000000..27ae750ca878
--- /dev/null
+++ b/drivers/hid/hid-lg.h
@@ -0,0 +1,18 @@
+#ifndef __HID_LG_H
+#define __HID_LG_H
+#include <linux/autoconf.h>
+#ifdef CONFIG_LOGITECH_FF
+int lgff_init(struct hid_device *hdev);
+#else
+static inline int lgff_init(struct hid_device *hdev) { return -1; }
+#endif
+#ifdef CONFIG_LOGIRUMBLEPAD2_FF
+int lg2ff_init(struct hid_device *hdev);
+#else
+static inline int lg2ff_init(struct hid_device *hdev) { return -1; }
+#endif
+#endif
diff --git a/drivers/hid/usbhid/hid-lg2ff.c b/drivers/hid/hid-lg2ff.c
index d469bd0061c9..4e6dc6e26523 100644
--- a/drivers/hid/usbhid/hid-lg2ff.c
+++ b/drivers/hid/hid-lg2ff.c
@@ -24,7 +24,9 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid.h"
+#include "usbhid/usbhid.h"
+#include "hid-lg.h"
 struct lg2ff_device {
        struct hid_report *report;
@@ -57,7 +59,7 @@ static int play_effect(struct input_dev *dev, void *data,
        return 0;
 }
-int hid_lg2ff_init(struct hid_device *hid)
+int lg2ff_init(struct hid_device *hid)
 {
        struct lg2ff_device *lg2ff;
        struct hid_report *report;
@@ -69,18 +71,18 @@ int hid_lg2ff_init(struct hid_device *hid)
        int error;
        if (list_empty(report_list)) {
-                printk(KERN_ERR "hid-lg2ff: no output report found\n");
+                dev_err(&hid->dev, "no output report found\n");
                return -ENODEV;
        }
        report = list_entry(report_list->next, struct hid_report, list);
        if (report->maxfield < 1) {
-                printk(KERN_ERR "hid-lg2ff: output report is empty\n");
+                dev_err(&hid->dev, "output report is empty\n");
                return -ENODEV;
        }
        if (report->field[0]->report_count < 7) {
-                printk(KERN_ERR "hid-lg2ff: not enough values in the field\n");
+                dev_err(&hid->dev, "not enough values in the field\n");
                return -ENODEV;
        }
@@ -107,7 +109,7 @@ int hid_lg2ff_init(struct hid_device *hid)
        usbhid_submit_report(hid, report, USB_DIR_OUT);
-        printk(KERN_INFO "Force feedback for Logitech Rumblepad 2 by "
+        dev_info(&hid->dev, "Force feedback for Logitech Rumblepad 2 by "
               "Anssi Hannula <anssi.hannula@gmail.com>\n");
        return 0;
diff --git a/drivers/hid/usbhid/hid-lgff.c b/drivers/hid/hid-lgff.c
index 4b7ab6a46d93..51aff08e10ce 100644
--- a/drivers/hid/usbhid/hid-lgff.c
+++ b/drivers/hid/hid-lgff.c
@@ -30,7 +30,9 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid.h"
+#include "usbhid/usbhid.h"
+#include "hid-lg.h"
 struct dev_type {
        u16 idVendor;
@@ -48,6 +50,12 @@ static const signed short ff_joystick[] = {
        -1
 };
+static const signed short ff_wheel[] = {
+        FF_CONSTANT,
+        FF_AUTOCENTER,
+        -1
+};
 static const struct dev_type devices[] = {
        { 0x046d, 0xc211, ff_rumble },
        { 0x046d, 0xc219, ff_rumble },
@@ -55,7 +63,7 @@ static const struct dev_type devices[] = {
        { 0x046d, 0xc286, ff_joystick },
        { 0x046d, 0xc294, ff_joystick },
        { 0x046d, 0xc295, ff_joystick },
-        { 0x046d, 0xca03, ff_joystick },
+        { 0x046d, 0xca03, ff_wheel },
 };
 static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
@@ -100,7 +108,24 @@ static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *ef
        return 0;
 }
-int hid_lgff_init(struct hid_device* hid)
+static void hid_lgff_set_autocenter(struct input_dev *dev, u16 magnitude)
+{
+        struct hid_device *hid = input_get_drvdata(dev);
+        struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
+        __s32 *value = report->field[0]->value;
+        magnitude = (magnitude >> 12) & 0xf;
+        *value++ = 0xfe;
+        *value++ = 0x0d;
+        *value++ = magnitude;   /* clockwise strength */
+        *value++ = magnitude;   /* counter-clockwise strength */
+        *value++ = 0x80;
+        *value++ = 0x00;
+        *value = 0x00;
+        usbhid_submit_report(hid, report, USB_DIR_OUT);
+}
+int lgff_init(struct hid_device* hid)
 {
        struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
        struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
@@ -145,6 +170,9 @@ int hid_lgff_init(struct hid_device* hid)
        if (error)
                return error;
+        if ( test_bit(FF_AUTOCENTER, dev->ffbit) )
+                dev->ff->set_autocenter = hid_lgff_set_autocenter;
        printk(KERN_INFO "Force feedback for Logitech force feedback devices by Johann Deneux <johann.deneux@it.uu.se>\n");
        return 0;
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
new file mode 100644
index 000000000000..d718b1607d0f
--- /dev/null
+++ b/drivers/hid/hid-microsoft.c
@@ -0,0 +1,219 @@
+/*
+ *  HID driver for some microsoft "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+#define MS_HIDINPUT     0x01
+#define MS_ERGONOMY     0x02
+#define MS_PRESENTER    0x04
+#define MS_RDESC        0x08
+#define MS_NOGET        0x10
+/*
+ * Microsoft Wireless Desktop Receiver (Model 1028) has several
+ * 'Usage Min/Max' where it ought to have 'Physical Min/Max'
+ */
+static void ms_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if ((quirks & MS_RDESC) && rsize == 571 && rdesc[284] == 0x19 &&
+                        rdesc[286] == 0x2a && rdesc[304] == 0x19 &&
+                        rdesc[306] == 0x29 && rdesc[352] == 0x1a &&
+                        rdesc[355] == 0x2a && rdesc[557] == 0x19 &&
+                        rdesc[559] == 0x29) {
+                dev_info(&hdev->dev, "fixing up Microsoft Wireless Receiver "
+                                "Model 1028 report descriptor\n");
+                rdesc[284] = rdesc[304] = rdesc[557] = 0x35;
+                rdesc[352] = 0x36;
+                rdesc[286] = rdesc[355] = 0x46;
+                rdesc[306] = rdesc[559] = 0x45;
+        }
+}
+#define ms_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int ms_ergonomy_kb_quirk(struct hid_input *hi, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct input_dev *input = hi->input;
+        switch (usage->hid & HID_USAGE) {
+        case 0xfd06: ms_map_key_clear(KEY_CHAT);        break;
+        case 0xfd07: ms_map_key_clear(KEY_PHONE);       break;
+        case 0xff05:
+                set_bit(EV_REP, input->evbit);
+                ms_map_key_clear(KEY_F13);
+                set_bit(KEY_F14, input->keybit);
+                set_bit(KEY_F15, input->keybit);
+                set_bit(KEY_F16, input->keybit);
+                set_bit(KEY_F17, input->keybit);
+                set_bit(KEY_F18, input->keybit);
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int ms_presenter_8k_quirk(struct hid_input *hi, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        case 0xfd08: ms_map_key_clear(KEY_FORWARD);     break;
+        case 0xfd09: ms_map_key_clear(KEY_BACK);        break;
+        case 0xfd0b: ms_map_key_clear(KEY_PLAYPAUSE);   break;
+        case 0xfd0e: ms_map_key_clear(KEY_CLOSE);       break;
+        case 0xfd0f: ms_map_key_clear(KEY_PLAY);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static int ms_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
+                return 0;
+        if (quirks & MS_ERGONOMY) {
+                int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max);
+                if (ret)
+                        return ret;
+        }
+        if ((quirks & MS_PRESENTER) &&
+                        ms_presenter_8k_quirk(hi, usage, bit, max))
+                return 1;
+        return 0;
+}
+static int ms_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+        /* Handling MS keyboards special buttons */
+        if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
+                struct input_dev *input = field->hidinput->input;
+                static unsigned int last_key = 0;
+                unsigned int key = 0;
+                switch (value) {
+                case 0x01: key = KEY_F14; break;
+                case 0x02: key = KEY_F15; break;
+                case 0x04: key = KEY_F16; break;
+                case 0x08: key = KEY_F17; break;
+                case 0x10: key = KEY_F18; break;
+                }
+                if (key) {
+                        input_event(input, usage->type, key, 1);
+                        last_key = key;
+                } else
+                        input_event(input, usage->type, last_key, 0);
+                return 1;
+        }
+        return 0;
+}
+static int ms_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        int ret;
+        hid_set_drvdata(hdev, (void *)quirks);
+        if (quirks & MS_NOGET)
+                hdev->quirks |= HID_QUIRK_NOGET;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | ((quirks & MS_HIDINPUT) ?
+                                HID_CONNECT_HIDINPUT_FORCE : 0));
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id ms_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV),
+                .driver_data = MS_HIDINPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
+                .driver_data = MS_ERGONOMY },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
+                .driver_data = MS_ERGONOMY | MS_RDESC },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),
+                .driver_data = MS_PRESENTER },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0),
+                .driver_data = MS_NOGET },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT),
+                .driver_data = MS_PRESENTER },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ms_devices);
+static struct hid_driver ms_driver = {
+        .name = "microsoft",
+        .id_table = ms_devices,
+        .report_fixup = ms_report_fixup,
+        .input_mapping = ms_input_mapping,
+        .event = ms_event,
+        .probe = ms_probe,
+};
+static int ms_init(void)
+{
+        return hid_register_driver(&ms_driver);
+}
+static void ms_exit(void)
+{
+        hid_unregister_driver(&ms_driver);
+}
+module_init(ms_init);
+module_exit(ms_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(microsoft);
diff --git a/drivers/hid/hid-monterey.c b/drivers/hid/hid-monterey.c
new file mode 100644
index 000000000000..f3a85a065f18
--- /dev/null
+++ b/drivers/hid/hid-monterey.c
@@ -0,0 +1,82 @@
+/*
+ *  HID driver for some monterey "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+static void mr_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 30 && rdesc[29] == 0x05 && rdesc[30] == 0x09) {
+                dev_info(&hdev->dev, "fixing up button/consumer in HID report "
+                                "descriptor\n");
+                rdesc[30] = 0x0c;
+        }
+}
+#define mr_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int mr_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+        switch (usage->hid & HID_USAGE) {
+        case 0x156: mr_map_key_clear(KEY_WORDPROCESSOR);        break;
+        case 0x157: mr_map_key_clear(KEY_SPREADSHEET);          break;
+        case 0x158: mr_map_key_clear(KEY_PRESENTATION);         break;
+        case 0x15c: mr_map_key_clear(KEY_STOP);                 break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static const struct hid_device_id mr_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, mr_devices);
+static struct hid_driver mr_driver = {
+        .name = "monterey",
+        .id_table = mr_devices,
+        .report_fixup = mr_report_fixup,
+        .input_mapping = mr_input_mapping,
+};
+static int mr_init(void)
+{
+        return hid_register_driver(&mr_driver);
+}
+static void mr_exit(void)
+{
+        hid_unregister_driver(&mr_driver);
+}
+module_init(mr_init);
+module_exit(mr_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(monterey);
diff --git a/drivers/hid/hid-petalynx.c b/drivers/hid/hid-petalynx.c
new file mode 100644
index 000000000000..10945fe12d50
--- /dev/null
+++ b/drivers/hid/hid-petalynx.c
@@ -0,0 +1,122 @@
+/*
+ *  HID driver for some petalynx "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+/* Petalynx Maxter Remote has maximum for consumer page set too low */
+static void pl_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 60 && rdesc[39] == 0x2a && rdesc[40] == 0xf5 &&
+                        rdesc[41] == 0x00 && rdesc[59] == 0x26 &&
+                        rdesc[60] == 0xf9 && rdesc[61] == 0x00) {
+                dev_info(&hdev->dev, "fixing up Petalynx Maxter Remote report "
+                                "descriptor\n");
+                rdesc[60] = 0xfa;
+                rdesc[40] = 0xfa;
+        }
+}
+#define pl_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int pl_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR) {
+                switch (usage->hid & HID_USAGE) {
+                case 0x05a: pl_map_key_clear(KEY_TEXT);         break;
+                case 0x05b: pl_map_key_clear(KEY_RED);          break;
+                case 0x05c: pl_map_key_clear(KEY_GREEN);        break;
+                case 0x05d: pl_map_key_clear(KEY_YELLOW);       break;
+                case 0x05e: pl_map_key_clear(KEY_BLUE);         break;
+                default:
+                        return 0;
+                }
+                return 1;
+        }
+        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
+                switch (usage->hid & HID_USAGE) {
+                case 0x0f6: pl_map_key_clear(KEY_NEXT);         break;
+                case 0x0fa: pl_map_key_clear(KEY_BACK);         break;
+                default:
+                        return 0;
+                }
+                return 1;
+        }
+        return 0;
+}
+static int pl_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        hdev->quirks |= HID_QUIRK_NOGET;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id pl_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, pl_devices);
+static struct hid_driver pl_driver = {
+        .name = "petalynx",
+        .id_table = pl_devices,
+        .report_fixup = pl_report_fixup,
+        .input_mapping = pl_input_mapping,
+        .probe = pl_probe,
+};
+static int pl_init(void)
+{
+        return hid_register_driver(&pl_driver);
+}
+static void pl_exit(void)
+{
+        hid_unregister_driver(&pl_driver);
+}
+module_init(pl_init);
+module_exit(pl_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(petalynx);
diff --git a/drivers/hid/usbhid/hid-plff.c b/drivers/hid/hid-pl.c
index 9eb83cf9d22b..acd815586182 100644
--- a/drivers/hid/usbhid/hid-plff.c
+++ b/drivers/hid/hid-pl.c
@@ -9,7 +9,7 @@
 *   - contains two reports, one for each port (HID_QUIRK_MULTI_INPUT)
 *
 *  0e8f:0003 "GreenAsia Inc.    USB Joystick     "
- *   - tested with Köng Gaming gamepad
+ *   - tested with K??ng Gaming gamepad
 *
 *  Copyright (c) 2007 Anssi Hannula <anssi.hannula@gmail.com>
 */
@@ -38,7 +38,11 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid.h"
+#include "hid-ids.h"
+#ifdef CONFIG_PANTHERLORD_FF
+#include "usbhid/usbhid.h"
 struct plff_device {
        struct hid_report *report;
@@ -66,7 +70,7 @@ static int hid_plff_play(struct input_dev *dev, void *data,
        return 0;
 }
-int hid_plff_init(struct hid_device *hid)
+static int plff_init(struct hid_device *hid)
 {
        struct plff_device *plff;
        struct hid_report *report;
@@ -86,7 +90,7 @@ int hid_plff_init(struct hid_device *hid)
           currently unknown. */
        if (list_empty(report_list)) {
-                printk(KERN_ERR "hid-plff: no output reports found\n");
+                dev_err(&hid->dev, "no output reports found\n");
                return -ENODEV;
        }
@@ -95,18 +99,19 @@ int hid_plff_init(struct hid_device *hid)
                report_ptr = report_ptr->next;
                if (report_ptr == report_list) {
-                        printk(KERN_ERR "hid-plff: required output report is missing\n");
+                        dev_err(&hid->dev, "required output report is "
+                                        "missing\n");
                        return -ENODEV;
                }
                report = list_entry(report_ptr, struct hid_report, list);
                if (report->maxfield < 1) {
-                        printk(KERN_ERR "hid-plff: no fields in the report\n");
+                        dev_err(&hid->dev, "no fields in the report\n");
                        return -ENODEV;
                }
                if (report->field[0]->report_count < 4) {
-                        printk(KERN_ERR "hid-plff: not enough values in the field\n");
+                        dev_err(&hid->dev, "not enough values in the field\n");
                        return -ENODEV;
                }
@@ -132,8 +137,70 @@ int hid_plff_init(struct hid_device *hid)
                usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
        }
-        printk(KERN_INFO "hid-plff: Force feedback for PantherLord/GreenAsia "
+        dev_info(&hid->dev, "Force feedback for PantherLord/GreenAsia "
               "devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
        return 0;
 }
+#else
+static inline int plff_init(struct hid_device *hid)
+{
+        return 0;
+}
+#endif
+static int pl_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        if (id->driver_data)
+                hdev->quirks |= HID_QUIRK_MULTI_INPUT;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err;
+        }
+        plff_init(hdev);
+        return 0;
+err:
+        return ret;
+}
+static const struct hid_device_id pl_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR),
+                .driver_data = 1 }, /* Twin USB Joystick */
+        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003), }, /* GreenAsia Inc. USB Joystick */
+        { }
+};
+MODULE_DEVICE_TABLE(hid, pl_devices);
+static struct hid_driver pl_driver = {
+        .name = "pantherlord",
+        .id_table = pl_devices,
+        .probe = pl_probe,
+};
+static int pl_init(void)
+{
+        return hid_register_driver(&pl_driver);
+}
+static void pl_exit(void)
+{
+        hid_unregister_driver(&pl_driver);
+}
+module_init(pl_init);
+module_exit(pl_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(pantherlord);
diff --git a/drivers/hid/hid-samsung.c b/drivers/hid/hid-samsung.c
new file mode 100644
index 000000000000..15f3c0492450
--- /dev/null
+++ b/drivers/hid/hid-samsung.c
@@ -0,0 +1,100 @@
+/*
+ *  HID driver for some samsung "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+/*
+ * Samsung IrDA remote controller (reports as Cypress USB Mouse).
+ *
+ * Vendor specific report #4 has a size of 48 bit,
+ * and therefore is not accepted when inspecting the descriptors.
+ * As a workaround we reinterpret the report as:
+ *   Variable type, count 6, size 8 bit, log. maximum 255
+ * The burden to reconstruct the data is moved into user space.
+ */
+static void samsung_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 182 && rdesc[175] == 0x25 && rdesc[176] == 0x40 &&
+                        rdesc[177] == 0x75 && rdesc[178] == 0x30 &&
+                        rdesc[179] == 0x95 && rdesc[180] == 0x01 &&
+                        rdesc[182] == 0x40) {
+                dev_info(&hdev->dev, "fixing up Samsung IrDA report "
+                                "descriptor\n");
+                rdesc[176] = 0xff;
+                rdesc[178] = 0x08;
+                rdesc[180] = 0x06;
+                rdesc[182] = 0x42;
+        }
+}
+static int samsung_probe(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        int ret;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, (HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDINPUT) |
+                        HID_CONNECT_HIDDEV_FORCE);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        return 0;
+err_free:
+        return ret;
+}
+static const struct hid_device_id samsung_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, samsung_devices);
+static struct hid_driver samsung_driver = {
+        .name = "samsung",
+        .id_table = samsung_devices,
+        .report_fixup = samsung_report_fixup,
+        .probe = samsung_probe,
+};
+static int samsung_init(void)
+{
+        return hid_register_driver(&samsung_driver);
+}
+static void samsung_exit(void)
+{
+        hid_unregister_driver(&samsung_driver);
+}
+module_init(samsung_init);
+module_exit(samsung_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(samsung);
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
new file mode 100644
index 000000000000..3af8095a7de1
--- /dev/null
+++ b/drivers/hid/hid-sony.c
@@ -0,0 +1,110 @@
+/*
+ *  HID driver for some sony "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "hid-ids.h"
+/*
+ * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
+ * to "operational".  Without this, the ps3 controller will not report any
+ * events.
+ */
+static int sony_set_operational(struct hid_device *hdev)
+{
+        struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+        struct usb_device *dev = interface_to_usbdev(intf);
+        __u16 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
+        int ret;
+        char *buf = kmalloc(18, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                                 HID_REQ_GET_REPORT,
+                                 USB_DIR_IN | USB_TYPE_CLASS |
+                                 USB_RECIP_INTERFACE,
+                                 (3 << 8) | 0xf2, ifnum, buf, 17,
+                                 USB_CTRL_GET_TIMEOUT);
+        if (ret < 0)
+                dev_err(&hdev->dev, "can't set operational mode\n");
+        kfree(buf);
+        return ret;
+}
+static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
+                        HID_CONNECT_HIDDEV_FORCE);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+        ret = sony_set_operational(hdev);
+        if (ret)
+                goto err_stop;
+        return 0;
+err_stop:
+        hid_hw_stop(hdev);
+err_free:
+        return ret;
+}
+static const struct hid_device_id sony_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, sony_devices);
+static struct hid_driver sony_driver = {
+        .name = "sony",
+        .id_table = sony_devices,
+        .probe = sony_probe,
+};
+static int sony_init(void)
+{
+        return hid_register_driver(&sony_driver);
+}
+static void sony_exit(void)
+{
+        hid_unregister_driver(&sony_driver);
+}
+module_init(sony_init);
+module_exit(sony_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(sony);
diff --git a/drivers/hid/hid-sunplus.c b/drivers/hid/hid-sunplus.c
new file mode 100644
index 000000000000..5ba68f7dbb78
--- /dev/null
+++ b/drivers/hid/hid-sunplus.c
@@ -0,0 +1,82 @@
+/*
+ *  HID driver for some sunplus "special" devices
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include "hid-ids.h"
+static void sp_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 107 && rdesc[104] == 0x26 && rdesc[105] == 0x80 &&
+                        rdesc[106] == 0x03) {
+                dev_info(&hdev->dev, "fixing up Sunplus Wireless Desktop "
+                                "report descriptor\n");
+                rdesc[105] = rdesc[110] = 0x03;
+                rdesc[106] = rdesc[111] = 0x21;
+        }
+}
+#define sp_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                EV_KEY, (c))
+static int sp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+        switch (usage->hid & HID_USAGE) {
+        case 0x2003: sp_map_key_clear(KEY_ZOOMIN);              break;
+        case 0x2103: sp_map_key_clear(KEY_ZOOMOUT);     break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+static const struct hid_device_id sp_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, sp_devices);
+static struct hid_driver sp_driver = {
+        .name = "sunplus",
+        .id_table = sp_devices,
+        .report_fixup = sp_report_fixup,
+        .input_mapping = sp_input_mapping,
+};
+static int sp_init(void)
+{
+        return hid_register_driver(&sp_driver);
+}
+static void sp_exit(void)
+{
+        hid_unregister_driver(&sp_driver);
+}
+module_init(sp_init);
+module_exit(sp_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(sunplus);
diff --git a/drivers/hid/usbhid/hid-tmff.c b/drivers/hid/hid-tmff.c
index 144578b1a00c..1b7cba0f7e1f 100644
--- a/drivers/hid/usbhid/hid-tmff.c
+++ b/drivers/hid/hid-tmff.c
@@ -27,23 +27,17 @@
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
+#include <linux/hid.h>
 #include <linux/input.h>
-#undef DEBUG
 #include <linux/usb.h>
-#include <linux/hid.h>
+#include "hid-ids.h"
-#include "usbhid.h"
+#include "usbhid/usbhid.h"
 /* Usages for thrustmaster devices I know about */
 #define THRUSTMASTER_USAGE_FF   (HID_UP_GENDESK | 0xbb)
-struct dev_type {
-        u16 idVendor;
-        u16 idProduct;
-        const signed short *ff;
-};
 static const signed short ff_rumble[] = {
        FF_RUMBLE,
        -1
@@ -54,21 +48,13 @@ static const signed short ff_joystick[] = {
        -1
 };
-static const struct dev_type devices[] = {
-        { 0x44f, 0xb300, ff_rumble },
-        { 0x44f, 0xb304, ff_rumble },
-        { 0x44f, 0xb651, ff_rumble },   /* FGT Rumble Force Wheel */
-        { 0x44f, 0xb654, ff_joystick }, /* FGT Force Feedback Wheel */
-};
 struct tmff_device {
        struct hid_report *report;
        struct hid_field *ff_field;
 };
 /* Changes values from 0 to 0xffff into values from minimum to maximum */
-static inline int hid_tmff_scale_u16(unsigned int in,
+static inline int tmff_scale_u16(unsigned int in, int minimum, int maximum)
-                                int minimum, int maximum)
 {
        int ret;
@@ -81,8 +67,7 @@ static inline int hid_tmff_scale_u16(unsigned int in,
 }
 /* Changes values from -0x80 to 0x7f into values from minimum to maximum */
-static inline int hid_tmff_scale_s8(int in,
+static inline int tmff_scale_s8(int in, int minimum, int maximum)
-                                    int minimum, int maximum)
 {
        int ret;
@@ -94,7 +79,8 @@ static inline int hid_tmff_scale_s8(int in,
        return ret;
 }
-static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
+static int tmff_play(struct input_dev *dev, void *data,
+                struct ff_effect *effect)
 {
        struct hid_device *hid = input_get_drvdata(dev);
        struct tmff_device *tmff = data;
@@ -104,10 +90,10 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
        switch (effect->type) {
        case FF_CONSTANT:
-                x = hid_tmff_scale_s8(effect->u.ramp.start_level,
+                x = tmff_scale_s8(effect->u.ramp.start_level,
                                        ff_field->logical_minimum,
                                        ff_field->logical_maximum);
-                y = hid_tmff_scale_s8(effect->u.ramp.end_level,
+                y = tmff_scale_s8(effect->u.ramp.end_level,
                                        ff_field->logical_minimum,
                                        ff_field->logical_maximum);
@@ -118,10 +104,10 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
                break;
        case FF_RUMBLE:
-                left = hid_tmff_scale_u16(effect->u.rumble.weak_magnitude,
+                left = tmff_scale_u16(effect->u.rumble.weak_magnitude,
                                        ff_field->logical_minimum,
                                        ff_field->logical_maximum);
-                right = hid_tmff_scale_u16(effect->u.rumble.strong_magnitude,
+                right = tmff_scale_u16(effect->u.rumble.strong_magnitude,
                                        ff_field->logical_minimum,
                                        ff_field->logical_maximum);
@@ -134,14 +120,14 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
        return 0;
 }
-int hid_tmff_init(struct hid_device *hid)
+static int tmff_init(struct hid_device *hid, const signed short *ff_bits)
 {
        struct tmff_device *tmff;
        struct hid_report *report;
        struct list_head *report_list;
-        struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
+        struct hid_input *hidinput = list_entry(hid->inputs.next,
+                                                        struct hid_input, list);
        struct input_dev *input_dev = hidinput->input;
-        const signed short *ff_bits = ff_joystick;
        int error;
        int i;
@@ -163,63 +149,121 @@ int hid_tmff_init(struct hid_device *hid)
                        switch (field->usage[0].hid) {
                        case THRUSTMASTER_USAGE_FF:
                                if (field->report_count < 2) {
-                                        warn("ignoring FF field with report_count < 2");
+                                        dev_warn(&hid->dev, "ignoring FF field "
+                                                "with report_count < 2\n");
                                        continue;
                                }
-                                if (field->logical_maximum == field->logical_minimum) {
+                                if (field->logical_maximum ==
-                                        warn("ignoring FF field with logical_maximum == logical_minimum");
+                                                field->logical_minimum) {
+                                        dev_warn(&hid->dev, "ignoring FF field "
+                                                        "with logical_maximum "
+                                                        "== logical_minimum\n");
                                        continue;
                                }
                                if (tmff->report && tmff->report != report) {
-                                        warn("ignoring FF field in other report");
+                                        dev_warn(&hid->dev, "ignoring FF field "
+                                                        "in other report\n");
                                        continue;
                                }
                                if (tmff->ff_field && tmff->ff_field != field) {
-                                        warn("ignoring duplicate FF field");
+                                        dev_warn(&hid->dev, "ignoring "
+                                                        "duplicate FF field\n");
                                        continue;
                                }
                                tmff->report = report;
                                tmff->ff_field = field;
-                                for (i = 0; i < ARRAY_SIZE(devices); i++) {
-                                        if (input_dev->id.vendor == devices[i].idVendor &&
-                                            input_dev->id.product == devices[i].idProduct) {
-                                                ff_bits = devices[i].ff;
-                                                break;
-                                        }
-                                }
                                for (i = 0; ff_bits[i] >= 0; i++)
                                        set_bit(ff_bits[i], input_dev->ffbit);
                                break;
                        default:
-                                warn("ignoring unknown output usage %08x", field->usage[0].hid);
+                                dev_warn(&hid->dev, "ignoring unknown output "
+                                                "usage %08x\n",
+                                                field->usage[0].hid);
                                continue;
                        }
                }
        }
        if (!tmff->report) {
-                err("cant find FF field in output reports\n");
+                dev_err(&hid->dev, "can't find FF field in output reports\n");
                error = -ENODEV;
                goto fail;
        }
-        error = input_ff_create_memless(input_dev, tmff, hid_tmff_play);
+        error = input_ff_create_memless(input_dev, tmff, tmff_play);
        if (error)
                goto fail;
-        info("Force feedback for ThrustMaster devices by Zinx Verituse <zinx@epicsol.org>");
+        dev_info(&hid->dev, "force feedback for ThrustMaster devices by Zinx "
+                        "Verituse <zinx@epicsol.org>");
        return 0;
- fail:
+fail:
        kfree(tmff);
        return error;
 }
+static int tm_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err;
+        }
+        tmff_init(hdev, (void *)id->driver_data);
+        return 0;
+err:
+        return ret;
+}
+static const struct hid_device_id tm_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300),
+                .driver_data = (unsigned long)ff_rumble },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304),
+                .driver_data = (unsigned long)ff_rumble },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651),   /* FGT Rumble Force Wheel */
+                .driver_data = (unsigned long)ff_rumble },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654),   /* FGT Force Feedback Wheel */
+                .driver_data = (unsigned long)ff_joystick },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, tm_devices);
+static struct hid_driver tm_driver = {
+        .name = "thrustmaster",
+        .id_table = tm_devices,
+        .probe = tm_probe,
+};
+static int tm_init(void)
+{
+        return hid_register_driver(&tm_driver);
+}
+static void tm_exit(void)
+{
+        hid_unregister_driver(&tm_driver);
+}
+module_init(tm_init);
+module_exit(tm_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(thrustmaster);
diff --git a/drivers/hid/usbhid/hid-zpff.c b/drivers/hid/hid-zpff.c
index 5a688274f6a3..ea82f3718b21 100644
--- a/drivers/hid/usbhid/hid-zpff.c
+++ b/drivers/hid/hid-zpff.c
@@ -21,16 +21,19 @@
 */
+#include <linux/hid.h>
 #include <linux/input.h>
 #include <linux/usb.h>
-#include <linux/hid.h>
-#include "usbhid.h"
+#include "hid-ids.h"
+#include "usbhid/usbhid.h"
 struct zpff_device {
        struct hid_report *report;
 };
-static int hid_zpff_play(struct input_dev *dev, void *data,
+static int zpff_play(struct input_dev *dev, void *data,
                         struct ff_effect *effect)
 {
        struct hid_device *hid = input_get_drvdata(dev);
@@ -58,7 +61,7 @@ static int hid_zpff_play(struct input_dev *dev, void *data,
        return 0;
 }
-int hid_zpff_init(struct hid_device *hid)
+static int zpff_init(struct hid_device *hid)
 {
        struct zpff_device *zpff;
        struct hid_report *report;
@@ -70,14 +73,14 @@ int hid_zpff_init(struct hid_device *hid)
        int error;
        if (list_empty(report_list)) {
-                printk(KERN_ERR "hid-zpff: no output report found\n");
+                dev_err(&hid->dev, "no output report found\n");
                return -ENODEV;
        }
        report = list_entry(report_list->next, struct hid_report, list);
        if (report->maxfield < 4) {
-                printk(KERN_ERR "hid-zpff: not enough fields in report\n");
+                dev_err(&hid->dev, "not enough fields in report\n");
                return -ENODEV;
        }
@@ -87,7 +90,7 @@ int hid_zpff_init(struct hid_device *hid)
        set_bit(FF_RUMBLE, dev->ffbit);
-        error = input_ff_create_memless(dev, zpff, hid_zpff_play);
+        error = input_ff_create_memless(dev, zpff, zpff_play);
        if (error) {
                kfree(zpff);
                return error;
@@ -100,8 +103,60 @@ int hid_zpff_init(struct hid_device *hid)
        zpff->report->field[3]->value[0] = 0x00;
        usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
-        printk(KERN_INFO "Force feedback for Zeroplus based devices by "
+        dev_info(&hid->dev, "force feedback for Zeroplus based devices by "
               "Anssi Hannula <anssi.hannula@gmail.com>\n");
        return 0;
 }
+static int zp_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err;
+        }
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err;
+        }
+        zpff_init(hdev);
+        return 0;
+err:
+        return ret;
+}
+static const struct hid_device_id zp_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, zp_devices);
+static struct hid_driver zp_driver = {
+        .name = "zeroplus",
+        .id_table = zp_devices,
+        .probe = zp_probe,
+};
+static int zp_init(void)
+{
+        return hid_register_driver(&zp_driver);
+}
+static void zp_exit(void)
+{
+        hid_unregister_driver(&zp_driver);
+}
+module_init(zp_init);
+module_exit(zp_exit);
+MODULE_LICENSE("GPL");
+HID_COMPAT_LOAD_DRIVER(zeroplus);
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index c40f0403edaf..497e0d1dd3c3 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -113,7 +113,7 @@ static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t
        if (!dev->hid_output_raw_report)
                return -ENODEV;
-        if (count > HID_MIN_BUFFER_SIZE) {
+        if (count > HID_MAX_BUFFER_SIZE) {
                printk(KERN_WARNING "hidraw: pid %d passed too large report\n",
                                task_pid_nr(current));
                return -EINVAL;
@@ -181,7 +181,7 @@ static int hidraw_open(struct inode *inode, struct file *file)
        dev = hidraw_table[minor];
        if (!dev->open++)
-                dev->hid->hid_open(dev->hid);
+                dev->hid->ll_driver->open(dev->hid);
 out_unlock:
        spin_unlock(&minors_lock);
@@ -207,7 +207,7 @@ static int hidraw_release(struct inode * inode, struct file * file)
        dev = hidraw_table[minor];
        if (!dev->open--) {
                if (list->hidraw->exist)
-                        dev->hid->hid_close(dev->hid);
+                        dev->hid->ll_driver->close(dev->hid);
                else
                        kfree(list->hidraw);
        }
@@ -367,7 +367,7 @@ void hidraw_disconnect(struct hid_device *hid)
        device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor));
        if (hidraw->open) {
-                hid->hid_close(hid);
+                hid->ll_driver->close(hid);
                wake_up_interruptible(&hidraw->wait);
        } else {
                kfree(hidraw);
diff --git a/drivers/hid/usbhid/Kconfig b/drivers/hid/usbhid/Kconfig
index 18f09104765c..5d9aa95fc3ef 100644
--- a/drivers/hid/usbhid/Kconfig
+++ b/drivers/hid/usbhid/Kconfig
@@ -24,88 +24,13 @@ config USB_HID
 comment "Input core support is needed for USB HID input layer or HIDBP support"
        depends on USB_HID && INPUT=n
-config USB_HIDINPUT_POWERBOOK
-        bool "Enable support for Apple laptop/aluminum USB special keys"
-        default n
-        depends on USB_HID
-        help
-          Say Y here if you want support for the special keys (Fn, Numlock) on
-          Apple iBooks, PowerBooks, MacBooks, MacBook Pros and aluminum USB
-          keyboards.
-          If unsure, say N.
-config HID_FF
-        bool "Force feedback support (EXPERIMENTAL)"
-        depends on USB_HID && EXPERIMENTAL
-        help
-          Say Y here is you want force feedback support for a few HID devices.
-          See below for a list of supported devices.
-          See <file:Documentation/input/ff.txt> for a description of the force
-          feedback API.
-          If unsure, say N.
 config HID_PID
        bool "PID device support"
-        depends on HID_FF
        help
          Say Y here if you have a PID-compliant device and wish to enable force
          feedback for it. Microsoft Sidewinder Force Feedback 2 is one of such
          devices.
-config LOGITECH_FF
-        bool "Logitech devices support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have one of these devices:
-          - Logitech WingMan Cordless RumblePad
-          - Logitech WingMan Cordless RumblePad 2
-          - Logitech WingMan Force 3D
-          - Logitech Formula Force EX
-          - Logitech MOMO Force wheel
-          and if you want to enable force feedback for them.
-          Note: if you say N here, this device will still be supported, but without
-          force feedback.
-config LOGIRUMBLEPAD2_FF
-        bool "Logitech Rumblepad 2 support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you want to enable force feedback support for Logitech
-          Rumblepad 2 devices.
-config PANTHERLORD_FF
-        bool "PantherLord/GreenAsia based device support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have a PantherLord/GreenAsia based game controller
-          or adapter and want to enable force feedback support for it.
-config THRUSTMASTER_FF
-        bool "ThrustMaster devices support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
-          a THRUSTMASTER Ferrari GT Rumble Force or Force Feedback Wheel,
-          and want to enable force feedback support for it.
-          Note: if you say N here, this device will still be supported, but without
-          force feedback.
-config ZEROPLUS_FF
-        bool "Zeroplus based game controller support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have a Zeroplus based game controller and want to
-          enable force feedback for it.
 config USB_HIDDEV
        bool "/dev/hiddev raw HID device support"
        depends on USB_HID
diff --git a/drivers/hid/usbhid/Makefile b/drivers/hid/usbhid/Makefile
index 00a7b7090192..1329ecb37a1c 100644
--- a/drivers/hid/usbhid/Makefile
+++ b/drivers/hid/usbhid/Makefile
@@ -13,24 +13,6 @@ endif
 ifeq ($(CONFIG_HID_PID),y)
        usbhid-objs     += hid-pidff.o
 endif
-ifeq ($(CONFIG_LOGITECH_FF),y)
-        usbhid-objs     += hid-lgff.o
-endif
-ifeq ($(CONFIG_LOGIRUMBLEPAD2_FF),y)
-        usbhid-objs     += hid-lg2ff.o
-endif
-ifeq ($(CONFIG_PANTHERLORD_FF),y)
-        usbhid-objs     += hid-plff.o
-endif
-ifeq ($(CONFIG_THRUSTMASTER_FF),y)
-        usbhid-objs     += hid-tmff.o
-endif
-ifeq ($(CONFIG_ZEROPLUS_FF),y)
-        usbhid-objs     += hid-zpff.o
-endif
-ifeq ($(CONFIG_HID_FF),y)
-        usbhid-objs     += hid-ff.o
-endif
 obj-$(CONFIG_USB_HID)           += usbhid.o
 obj-$(CONFIG_USB_KBD)           += usbkbd.o
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 27fe4d8912cb..1d3b8a394d46 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -44,8 +44,6 @@
 #define DRIVER_DESC "USB HID core driver"
 #define DRIVER_LICENSE "GPL"
-static char *hid_types[] = {"Device", "Pointer", "Mouse", "Device", "Joystick",
-                                "Gamepad", "Keyboard", "Keypad", "Multi-Axis Controller"};
 /*
 * Module parameters.
 */
@@ -61,12 +59,6 @@ MODULE_PARM_DESC(quirks, "Add/modify USB HID quirks by specifying "
                " quirks=vendorID:productID:quirks"
                " where vendorID, productID, and quirks are all in"
                " 0x-prefixed hex");
-static char *rdesc_quirks_param[MAX_USBHID_BOOT_QUIRKS] = { [ 0 ... (MAX_USBHID_BOOT_QUIRKS - 1) ] = NULL };
-module_param_array_named(rdesc_quirks, rdesc_quirks_param, charp, NULL, 0444);
-MODULE_PARM_DESC(rdesc_quirks, "Add/modify report descriptor quirks by specifying "
-                " rdesc_quirks=vendorID:productID:rdesc_quirks"
-                " where vendorID, productID, and rdesc_quirks are all in"
-                " 0x-prefixed hex");
 /*
 * Input submission and I/O error handler.
 */
@@ -197,31 +189,32 @@ static void hid_irq_in(struct urb *urb)
        int                     status;
        switch (urb->status) {
-                case 0:                 /* success */
+        case 0:                 /* success */
-                        usbhid->retry_delay = 0;
+                usbhid->retry_delay = 0;
-                        hid_input_report(urb->context, HID_INPUT_REPORT,
+                hid_input_report(urb->context, HID_INPUT_REPORT,
-                                         urb->transfer_buffer,
+                                 urb->transfer_buffer,
-                                         urb->actual_length, 1);
+                                 urb->actual_length, 1);
-                        break;
+                break;
-                case -EPIPE:            /* stall */
+        case -EPIPE:            /* stall */
-                        clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
-                        set_bit(HID_CLEAR_HALT, &usbhid->iofl);
+                set_bit(HID_CLEAR_HALT, &usbhid->iofl);
-                        schedule_work(&usbhid->reset_work);
+                schedule_work(&usbhid->reset_work);
-                        return;
+                return;
-                case -ECONNRESET:       /* unlink */
+        case -ECONNRESET:       /* unlink */
-                case -ENOENT:
+        case -ENOENT:
-                case -ESHUTDOWN:        /* unplug */
+        case -ESHUTDOWN:        /* unplug */
-                        clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
-                        return;
+                return;
-                case -EILSEQ:           /* protocol error or unplug */
+        case -EILSEQ:           /* protocol error or unplug */
-                case -EPROTO:           /* protocol error or unplug */
+        case -EPROTO:           /* protocol error or unplug */
-                case -ETIME:            /* protocol error or unplug */
+        case -ETIME:            /* protocol error or unplug */
-                case -ETIMEDOUT:        /* Should never happen, but... */
+        case -ETIMEDOUT:        /* Should never happen, but... */
-                        clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
-                        hid_io_error(hid);
+                hid_io_error(hid);
-                        return;
+                return;
-                default:                /* error */
+        default:                /* error */
-                        warn("input irq status %d received", urb->status);
+                dev_warn(&urb->dev->dev, "input irq status %d  "
+                                "received\n", urb->status);
        }
        status = usb_submit_urb(urb, GFP_ATOMIC);
@@ -240,13 +233,16 @@ static void hid_irq_in(struct urb *urb)
 static int hid_submit_out(struct hid_device *hid)
 {
        struct hid_report *report;
+        char *raw_report;
        struct usbhid_device *usbhid = hid->driver_data;
-        report = usbhid->out[usbhid->outtail];
+        report = usbhid->out[usbhid->outtail].report;
+        raw_report = usbhid->out[usbhid->outtail].raw_report;
-        hid_output_report(report, usbhid->outbuf);
        usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
        usbhid->urbout->dev = hid_to_usb_dev(hid);
+        memcpy(usbhid->outbuf, raw_report, usbhid->urbout->transfer_buffer_length);
+        kfree(raw_report);
        dbg_hid("submitting out urb\n");
@@ -262,17 +258,20 @@ static int hid_submit_ctrl(struct hid_device *hid)
 {
        struct hid_report *report;
        unsigned char dir;
+        char *raw_report;
        int len;
        struct usbhid_device *usbhid = hid->driver_data;
        report = usbhid->ctrl[usbhid->ctrltail].report;
+        raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;
        dir = usbhid->ctrl[usbhid->ctrltail].dir;
        len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
        if (dir == USB_DIR_OUT) {
-                hid_output_report(report, usbhid->ctrlbuf);
                usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
                usbhid->urbctrl->transfer_buffer_length = len;
+                memcpy(usbhid->ctrlbuf, raw_report, len);
+                kfree(raw_report);
        } else {
                int maxpacket, padlen;
@@ -319,17 +318,18 @@ static void hid_irq_out(struct urb *urb)
        int unplug = 0;
        switch (urb->status) {
-                case 0:                 /* success */
+        case 0:                 /* success */
-                        break;
+                break;
-                case -ESHUTDOWN:        /* unplug */
+        case -ESHUTDOWN:        /* unplug */
-                        unplug = 1;
+                unplug = 1;
-                case -EILSEQ:           /* protocol error or unplug */
+        case -EILSEQ:           /* protocol error or unplug */
-                case -EPROTO:           /* protocol error or unplug */
+        case -EPROTO:           /* protocol error or unplug */
-                case -ECONNRESET:       /* unlink */
+        case -ECONNRESET:       /* unlink */
-                case -ENOENT:
+        case -ENOENT:
-                        break;
+                break;
-                default:                /* error */
+        default:                /* error */
-                        warn("output irq status %d received", urb->status);
+                dev_warn(&urb->dev->dev, "output irq status %d "
+                                "received\n", urb->status);
        }
        spin_lock_irqsave(&usbhid->outlock, flags);
@@ -367,21 +367,23 @@ static void hid_ctrl(struct urb *urb)
        spin_lock_irqsave(&usbhid->ctrllock, flags);
        switch (urb->status) {
-                case 0:                 /* success */
+        case 0:                 /* success */
-                        if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
+                if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
-                                hid_input_report(urb->context, usbhid->ctrl[usbhid->ctrltail].report->type,
+                        hid_input_report(urb->context,
-                                                urb->transfer_buffer, urb->actual_length, 0);
+                                usbhid->ctrl[usbhid->ctrltail].report->type,
-                        break;
+                                urb->transfer_buffer, urb->actual_length, 0);
-                case -ESHUTDOWN:        /* unplug */
+                break;
-                        unplug = 1;
+        case -ESHUTDOWN:        /* unplug */
-                case -EILSEQ:           /* protocol error or unplug */
+                unplug = 1;
-                case -EPROTO:           /* protocol error or unplug */
+        case -EILSEQ:           /* protocol error or unplug */
-                case -ECONNRESET:       /* unlink */
+        case -EPROTO:           /* protocol error or unplug */
-                case -ENOENT:
+        case -ECONNRESET:       /* unlink */
-                case -EPIPE:            /* report not available */
+        case -ENOENT:
-                        break;
+        case -EPIPE:            /* report not available */
-                default:                /* error */
+                break;
-                        warn("ctrl urb status %d received", urb->status);
+        default:                /* error */
+                dev_warn(&urb->dev->dev, "ctrl urb status %d "
+                                "received\n", urb->status);
        }
        if (unplug)
@@ -408,6 +410,7 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
        int head;
        unsigned long flags;
        struct usbhid_device *usbhid = hid->driver_data;
+        int len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
        if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN)
                return;
@@ -418,11 +421,18 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
                if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
                        spin_unlock_irqrestore(&usbhid->outlock, flags);
-                        warn("output queue full");
+                        dev_warn(&hid->dev, "output queue full\n");
                        return;
                }
-                usbhid->out[usbhid->outhead] = report;
+                usbhid->out[usbhid->outhead].raw_report = kmalloc(len, GFP_ATOMIC);
+                if (!usbhid->out[usbhid->outhead].raw_report) {
+                        spin_unlock_irqrestore(&usbhid->outlock, flags);
+                        warn("output queueing failed");
+                        return;
+                }
+                hid_output_report(report, usbhid->out[usbhid->outhead].raw_report);
+                usbhid->out[usbhid->outhead].report = report;
                usbhid->outhead = head;
                if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl))
@@ -437,10 +447,19 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
        if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
                spin_unlock_irqrestore(&usbhid->ctrllock, flags);
-                warn("control queue full");
+                dev_warn(&hid->dev, "control queue full\n");
                return;
        }
+        if (dir == USB_DIR_OUT) {
+                usbhid->ctrl[usbhid->ctrlhead].raw_report = kmalloc(len, GFP_ATOMIC);
+                if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) {
+                        spin_unlock_irqrestore(&usbhid->ctrllock, flags);
+                        warn("control queueing failed");
+                        return;
+                }
+                hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report);
+        }
        usbhid->ctrl[usbhid->ctrlhead].report = report;
        usbhid->ctrl[usbhid->ctrlhead].dir = dir;
        usbhid->ctrlhead = head;
@@ -451,6 +470,7 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
        spin_unlock_irqrestore(&usbhid->ctrllock, flags);
 }
+EXPORT_SYMBOL_GPL(usbhid_submit_report);
 static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
@@ -465,7 +485,7 @@ static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, un
                return -1;
        if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
-                warn("event field not found");
+                dev_warn(&dev->dev, "event field not found\n");
                return -1;
        }
@@ -568,7 +588,7 @@ void usbhid_init_reports(struct hid_device *hid)
        }
        if (err)
-                warn("timeout initializing reports");
+                dev_warn(&hid->dev, "timeout initializing reports\n");
 }
 /*
@@ -598,7 +618,7 @@ static int hid_find_field_early(struct hid_device *hid, unsigned int page,
        return -1;
 }
-static void usbhid_set_leds(struct hid_device *hid)
+void usbhid_set_leds(struct hid_device *hid)
 {
        struct hid_field *field;
        int offset;
@@ -608,6 +628,7 @@ static void usbhid_set_leds(struct hid_device *hid)
                usbhid_submit_report(hid, field->report, USB_DIR_OUT);
        }
 }
+EXPORT_SYMBOL_GPL(usbhid_set_leds);
 /*
 * Traverse the supplied list of reports and find the longest
@@ -675,43 +696,16 @@ static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
        usb_buffer_free(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma);
 }
-/*
+static int usbhid_parse(struct hid_device *hid)
- * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
- * to "operational".  Without this, the ps3 controller will not report any
- * events.
- */
-static void hid_fixup_sony_ps3_controller(struct usb_device *dev, int ifnum)
-{
-        int result;
-        char *buf = kmalloc(18, GFP_KERNEL);
-        if (!buf)
-                return;
-        result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
-                                 HID_REQ_GET_REPORT,
-                                 USB_DIR_IN | USB_TYPE_CLASS |
-                                 USB_RECIP_INTERFACE,
-                                 (3 << 8) | 0xf2, ifnum, buf, 17,
-                                 USB_CTRL_GET_TIMEOUT);
-        if (result < 0)
-                err_hid("%s failed: %d\n", __func__, result);
-        kfree(buf);
-}
-static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 {
+        struct usb_interface *intf = to_usb_interface(hid->dev.parent);
        struct usb_host_interface *interface = intf->cur_altsetting;
        struct usb_device *dev = interface_to_usbdev (intf);
        struct hid_descriptor *hdesc;
-        struct hid_device *hid;
        u32 quirks = 0;
-        unsigned int insize = 0, rsize = 0;
+        unsigned int rsize = 0;
        char *rdesc;
-        int n, len;
+        int ret, n;
-        struct usbhid_device *usbhid;
        quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
                        le16_to_cpu(dev->descriptor.idProduct));
@@ -724,63 +718,75 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                                quirks |= HID_QUIRK_NOGET;
        }
-        if (quirks & HID_QUIRK_IGNORE)
-                return NULL;
-        if ((quirks & HID_QUIRK_IGNORE_MOUSE) &&
-                (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE))
-                        return NULL;
        if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
            (!interface->desc.bNumEndpoints ||
             usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
                dbg_hid("class descriptor not present\n");
-                return NULL;
+                return -ENODEV;
        }
+        hid->version = le16_to_cpu(hdesc->bcdHID);
+        hid->country = hdesc->bCountryCode;
        for (n = 0; n < hdesc->bNumDescriptors; n++)
                if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT)
                        rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength);
        if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
                dbg_hid("weird size of report descriptor (%u)\n", rsize);
-                return NULL;
+                return -EINVAL;
        }
        if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
                dbg_hid("couldn't allocate rdesc memory\n");
-                return NULL;
+                return -ENOMEM;
        }
        hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);
-        if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {
+        ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber,
+                        HID_DT_REPORT, rdesc, rsize);
+        if (ret < 0) {
                dbg_hid("reading report descriptor failed\n");
                kfree(rdesc);
-                return NULL;
+                goto err;
        }
-        usbhid_fixup_report_descriptor(le16_to_cpu(dev->descriptor.idVendor),
-                        le16_to_cpu(dev->descriptor.idProduct), rdesc,
-                        rsize, rdesc_quirks_param);
        dbg_hid("report descriptor (size %u, read %d) = ", rsize, n);
        for (n = 0; n < rsize; n++)
                dbg_hid_line(" %02x", (unsigned char) rdesc[n]);
        dbg_hid_line("\n");
-        if (!(hid = hid_parse_report(rdesc, n))) {
+        ret = hid_parse_report(hid, rdesc, rsize);
+        kfree(rdesc);
+        if (ret) {
                dbg_hid("parsing report descriptor failed\n");
-                kfree(rdesc);
+                goto err;
-                return NULL;
        }
-        kfree(rdesc);
        hid->quirks = quirks;
-        if (!(usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL)))
+        return 0;
-                goto fail_no_usbhid;
+err:
+        return ret;
+}
+static int usbhid_start(struct hid_device *hid)
+{
+        struct usb_interface *intf = to_usb_interface(hid->dev.parent);
+        struct usb_host_interface *interface = intf->cur_altsetting;
+        struct usb_device *dev = interface_to_usbdev(intf);
+        struct usbhid_device *usbhid;
+        unsigned int n, insize = 0;
+        int ret;
+        WARN_ON(hid->driver_data);
+        usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL);
+        if (usbhid == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
        hid->driver_data = usbhid;
        usbhid->hid = hid;
@@ -799,28 +805,11 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                insize = HID_MAX_BUFFER_SIZE;
        if (hid_alloc_buffers(dev, hid)) {
-                hid_free_buffers(dev, hid);
+                ret = -ENOMEM;
                goto fail;
        }
-        hid->name[0] = 0;
-        if (dev->manufacturer)
-                strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
-        if (dev->product) {
-                if (dev->manufacturer)
-                        strlcat(hid->name, " ", sizeof(hid->name));
-                strlcat(hid->name, dev->product, sizeof(hid->name));
-        }
-        if (!strlen(hid->name))
-                snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
-                         le16_to_cpu(dev->descriptor.idVendor),
-                         le16_to_cpu(dev->descriptor.idProduct));
        for (n = 0; n < interface->desc.bNumEndpoints; n++) {
                struct usb_endpoint_descriptor *endpoint;
                int pipe;
                int interval;
@@ -832,7 +821,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                interval = endpoint->bInterval;
                /* Some vendors give fullspeed interval on highspeed devides */
-                if (quirks & HID_QUIRK_FULLSPEED_INTERVAL  &&
+                if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
                    dev->speed == USB_SPEED_HIGH) {
                        interval = fls(endpoint->bInterval*8);
                        printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
@@ -843,6 +832,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)
                        interval = hid_mousepoll_interval;
+                ret = -ENOMEM;
                if (usb_endpoint_dir_in(endpoint)) {
                        if (usbhid->urbin)
                                continue;
@@ -868,6 +858,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        if (!usbhid->urbin) {
                err_hid("couldn't find an input interrupt endpoint");
+                ret = -ENODEV;
                goto fail;
        }
@@ -879,44 +870,25 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        spin_lock_init(&usbhid->outlock);
        spin_lock_init(&usbhid->ctrllock);
-        hid->version = le16_to_cpu(hdesc->bcdHID);
-        hid->country = hdesc->bCountryCode;
-        hid->dev = &intf->dev;
        usbhid->intf = intf;
        usbhid->ifnum = interface->desc.bInterfaceNumber;
-        hid->bus = BUS_USB;
-        hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
-        hid->product = le16_to_cpu(dev->descriptor.idProduct);
-        usb_make_path(dev, hid->phys, sizeof(hid->phys));
-        strlcat(hid->phys, "/input", sizeof(hid->phys));
-        len = strlen(hid->phys);
-        if (len < sizeof(hid->phys) - 1)
-                snprintf(hid->phys + len, sizeof(hid->phys) - len,
-                         "%d", intf->altsetting[0].desc.bInterfaceNumber);
-        if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
-                hid->uniq[0] = 0;
        usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
-        if (!usbhid->urbctrl)
+        if (!usbhid->urbctrl) {
+                ret = -ENOMEM;
                goto fail;
+        }
        usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
                             usbhid->ctrlbuf, 1, hid_ctrl, hid);
        usbhid->urbctrl->setup_dma = usbhid->cr_dma;
        usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
        usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
-        hid->hidinput_input_event = usb_hidinput_input_event;
-        hid->hid_open = usbhid_open;
+        usbhid_init_reports(hid);
-        hid->hid_close = usbhid_close;
+        hid_dump_device(hid);
-#ifdef CONFIG_USB_HIDDEV
-        hid->hiddev_hid_event = hiddev_hid_event;
+        return 0;
-        hid->hiddev_report_event = hiddev_report_event;
-#endif
-        hid->hid_output_raw_report = usbhid_output_raw_report;
-        return hid;
 fail:
        usb_free_urb(usbhid->urbin);
@@ -924,24 +896,18 @@ fail:
        usb_free_urb(usbhid->urbctrl);
        hid_free_buffers(dev, hid);
        kfree(usbhid);
-fail_no_usbhid:
+err:
-        hid_free_device(hid);
+        return ret;
-        return NULL;
 }
-static void hid_disconnect(struct usb_interface *intf)
+static void usbhid_stop(struct hid_device *hid)
 {
-        struct hid_device *hid = usb_get_intfdata (intf);
+        struct usbhid_device *usbhid = hid->driver_data;
-        struct usbhid_device *usbhid;
-        if (!hid)
+        if (WARN_ON(!usbhid))
                return;
-        usbhid = hid->driver_data;
        spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
-        usb_set_intfdata(intf, NULL);
        set_bit(HID_DISCONNECTED, &usbhid->iofl);
        spin_unlock_irq(&usbhid->inlock);
        usb_kill_urb(usbhid->urbin);
@@ -958,86 +924,100 @@ static void hid_disconnect(struct usb_interface *intf)
        if (hid->claimed & HID_CLAIMED_HIDRAW)
                hidraw_disconnect(hid);
+        hid->claimed = 0;
        usb_free_urb(usbhid->urbin);
        usb_free_urb(usbhid->urbctrl);
        usb_free_urb(usbhid->urbout);
        hid_free_buffers(hid_to_usb_dev(hid), hid);
        kfree(usbhid);
-        hid_free_device(hid);
+        hid->driver_data = NULL;
 }
+static struct hid_ll_driver usb_hid_driver = {
+        .parse = usbhid_parse,
+        .start = usbhid_start,
+        .stop = usbhid_stop,
+        .open = usbhid_open,
+        .close = usbhid_close,
+        .hidinput_input_event = usb_hidinput_input_event,
+};
 static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
+        struct usb_device *dev = interface_to_usbdev(intf);
        struct hid_device *hid;
-        char path[64];
+        size_t len;
-        int i;
+        int ret;
-        char *c;
        dbg_hid("HID probe called for ifnum %d\n",
                        intf->altsetting->desc.bInterfaceNumber);
-        if (!(hid = usb_hid_configure(intf)))
+        hid = hid_allocate_device();
-                return -ENODEV;
+        if (IS_ERR(hid))
+                return PTR_ERR(hid);
-        usbhid_init_reports(hid);
-        hid_dump_device(hid);
-        if (hid->quirks & HID_QUIRK_RESET_LEDS)
-                usbhid_set_leds(hid);
-        if (!hidinput_connect(hid))
-                hid->claimed |= HID_CLAIMED_INPUT;
-        if (!hiddev_connect(hid))
-                hid->claimed |= HID_CLAIMED_HIDDEV;
-        if (!hidraw_connect(hid))
-                hid->claimed |= HID_CLAIMED_HIDRAW;
        usb_set_intfdata(intf, hid);
+        hid->ll_driver = &usb_hid_driver;
+        hid->hid_output_raw_report = usbhid_output_raw_report;
+        hid->ff_init = hid_pidff_init;
+#ifdef CONFIG_USB_HIDDEV
+        hid->hiddev_connect = hiddev_connect;
+        hid->hiddev_hid_event = hiddev_hid_event;
+        hid->hiddev_report_event = hiddev_report_event;
+#endif
+        hid->dev.parent = &intf->dev;
+        hid->bus = BUS_USB;
+        hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
+        hid->product = le16_to_cpu(dev->descriptor.idProduct);
+        hid->name[0] = 0;
-        if (!hid->claimed) {
+        if (dev->manufacturer)
-                printk ("HID device claimed by neither input, hiddev nor hidraw\n");
+                strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
-                hid_disconnect(intf);
-                return -ENODEV;
+        if (dev->product) {
+                if (dev->manufacturer)
+                        strlcat(hid->name, " ", sizeof(hid->name));
+                strlcat(hid->name, dev->product, sizeof(hid->name));
        }
-        if ((hid->claimed & HID_CLAIMED_INPUT))
+        if (!strlen(hid->name))
-                hid_ff_init(hid);
+                snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
+                         le16_to_cpu(dev->descriptor.idVendor),
+                         le16_to_cpu(dev->descriptor.idProduct));
-        if (hid->quirks & HID_QUIRK_SONY_PS3_CONTROLLER)
+        usb_make_path(dev, hid->phys, sizeof(hid->phys));
-                hid_fixup_sony_ps3_controller(interface_to_usbdev(intf),
+        strlcat(hid->phys, "/input", sizeof(hid->phys));
-                        intf->cur_altsetting->desc.bInterfaceNumber);
+        len = strlen(hid->phys);
+        if (len < sizeof(hid->phys) - 1)
+                snprintf(hid->phys + len, sizeof(hid->phys) - len,
+                         "%d", intf->altsetting[0].desc.bInterfaceNumber);
-        printk(KERN_INFO);
+        if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
+                hid->uniq[0] = 0;
-        if (hid->claimed & HID_CLAIMED_INPUT)
+        ret = hid_add_device(hid);
-                printk("input");
+        if (ret) {
-        if ((hid->claimed & HID_CLAIMED_INPUT) && ((hid->claimed & HID_CLAIMED_HIDDEV) ||
+                if (ret != -ENODEV)
-                                hid->claimed & HID_CLAIMED_HIDRAW))
+                        dev_err(&intf->dev, "can't add hid device: %d\n", ret);
-                printk(",");
+                goto err;
-        if (hid->claimed & HID_CLAIMED_HIDDEV)
-                printk("hiddev%d", hid->minor);
-        if ((hid->claimed & HID_CLAIMED_INPUT) && (hid->claimed & HID_CLAIMED_HIDDEV) &&
-                        (hid->claimed & HID_CLAIMED_HIDRAW))
-                printk(",");
-        if (hid->claimed & HID_CLAIMED_HIDRAW)
-                printk("hidraw%d", ((struct hidraw*)hid->hidraw)->minor);
-        c = "Device";
-        for (i = 0; i < hid->maxcollection; i++) {
-                if (hid->collection[i].type == HID_COLLECTION_APPLICATION &&
-                    (hid->collection[i].usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
-                    (hid->collection[i].usage & 0xffff) < ARRAY_SIZE(hid_types)) {
-                        c = hid_types[hid->collection[i].usage & 0xffff];
-                        break;
-                }
        }
-        usb_make_path(interface_to_usbdev(intf), path, 63);
+        return 0;
+err:
+        hid_destroy_device(hid);
+        return ret;
+}
-        printk(": USB HID v%x.%02x %s [%s] on %s\n",
+static void hid_disconnect(struct usb_interface *intf)
-                hid->version >> 8, hid->version & 0xff, c, hid->name, path);
+{
+        struct hid_device *hid = usb_get_intfdata(intf);
-        return 0;
+        if (WARN_ON(!hid))
+                return;
+        hid_destroy_device(hid);
 }
 static int hid_suspend(struct usb_interface *intf, pm_message_t message)
@@ -1107,9 +1087,22 @@ static struct usb_driver hid_driver = {
        .supports_autosuspend = 1,
 };
+static const struct hid_device_id hid_usb_table[] = {
+        { HID_USB_DEVICE(HID_ANY_ID, HID_ANY_ID) },
+        { }
+};
+static struct hid_driver hid_usb_driver = {
+        .name = "generic-usb",
+        .id_table = hid_usb_table,
+};
 static int __init hid_init(void)
 {
        int retval;
+        retval = hid_register_driver(&hid_usb_driver);
+        if (retval)
+                goto hid_register_fail;
        retval = usbhid_quirks_init(quirks_param);
        if (retval)
                goto usbhid_quirks_init_fail;
@@ -1119,7 +1112,8 @@ static int __init hid_init(void)
        retval = usb_register(&hid_driver);
        if (retval)
                goto usb_register_fail;
-        info(DRIVER_VERSION ":" DRIVER_DESC);
+        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+                        DRIVER_DESC "\n");
        return 0;
 usb_register_fail:
@@ -1127,6 +1121,8 @@ usb_register_fail:
 hiddev_init_fail:
        usbhid_quirks_exit();
 usbhid_quirks_init_fail:
+        hid_unregister_driver(&hid_usb_driver);
+hid_register_fail:
        return retval;
 }
@@ -1135,6 +1131,7 @@ static void __exit hid_exit(void)
        usb_deregister(&hid_driver);
        hiddev_exit();
        usbhid_quirks_exit();
+        hid_unregister_driver(&hid_usb_driver);
 }
 module_init(hid_init);
diff --git a/drivers/hid/usbhid/hid-ff.c b/drivers/hid/usbhid/hid-ff.c
deleted file mode 100644
index 1d0dac52f166..000000000000
--- a/drivers/hid/usbhid/hid-ff.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- *  Force feedback support for hid devices.
- *  Not all hid devices use the same protocol. For example, some use PID,
- *  other use their own proprietary procotol.
- *
- *  Copyright (c) 2002-2004 Johann Deneux
- */
-/*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- * Should you need to contact me, the author, you can do so by
- * e-mail - mail your message to <johann.deneux@it.uu.se>
- */
-#include <linux/input.h>
-#undef DEBUG
-#include <linux/usb.h>
-#include <linux/hid.h>
-#include "usbhid.h"
-/*
- * This table contains pointers to initializers. To add support for new
- * devices, you need to add the USB vendor and product ids here.
- */
-struct hid_ff_initializer {
-        u16 idVendor;
-        u16 idProduct;
-        int (*init)(struct hid_device*);
-};
-/*
- * We try pidff when no other driver is found because PID is the
- * standards compliant way of implementing force feedback in HID.
- * pidff_init() will quickly abort if the device doesn't appear to
- * be a PID device
- */
-static struct hid_ff_initializer inits[] = {
-#ifdef CONFIG_LOGITECH_FF
-        { 0x46d, 0xc211, hid_lgff_init }, /* Logitech Cordless rumble pad */
-        { 0x46d, 0xc219, hid_lgff_init }, /* Logitech Cordless rumble pad 2 */
-        { 0x46d, 0xc283, hid_lgff_init }, /* Logitech Wingman Force 3d */
-        { 0x46d, 0xc286, hid_lgff_init }, /* Logitech Force 3D Pro Joystick */
-        { 0x46d, 0xc294, hid_lgff_init }, /* Logitech Formula Force EX */
-        { 0x46d, 0xc295, hid_lgff_init }, /* Logitech MOMO force wheel */
-        { 0x46d, 0xca03, hid_lgff_init }, /* Logitech MOMO force wheel */
-#endif
-#ifdef CONFIG_LOGIRUMBLEPAD2_FF
-        { 0x46d, 0xc218, hid_lg2ff_init }, /* Logitech Rumblepad 2 */
-#endif
-#ifdef CONFIG_PANTHERLORD_FF
-        { 0x810, 0x0001, hid_plff_init }, /* "Twin USB Joystick" */
-        { 0xe8f, 0x0003, hid_plff_init }, /* "GreenAsia Inc.    USB Joystick     " */
-#endif
-#ifdef CONFIG_THRUSTMASTER_FF
-        { 0x44f, 0xb300, hid_tmff_init },
-        { 0x44f, 0xb304, hid_tmff_init },
-        { 0x44f, 0xb651, hid_tmff_init }, /* FGT Rumble Force Wheel */
-        { 0x44f, 0xb654, hid_tmff_init }, /* FGT Force Feedback Wheel */
-#endif
-#ifdef CONFIG_ZEROPLUS_FF
-        { 0xc12, 0x0005, hid_zpff_init },
-        { 0xc12, 0x0030, hid_zpff_init },
-#endif
-        { 0,     0,      hid_pidff_init}  /* Matches anything */
-};
-int hid_ff_init(struct hid_device* hid)
-{
-        struct hid_ff_initializer *init;
-        int vendor = le16_to_cpu(hid_to_usb_dev(hid)->descriptor.idVendor);
-        int product = le16_to_cpu(hid_to_usb_dev(hid)->descriptor.idProduct);
-        for (init = inits; init->idVendor; init++)
-                if (init->idVendor == vendor && init->idProduct == product)
-                        break;
-        return init->init(hid);
-}
-EXPORT_SYMBOL_GPL(hid_ff_init);
diff --git a/drivers/hid/usbhid/hid-pidff.c b/drivers/hid/usbhid/hid-pidff.c
index 011326178c06..484e3eec2f88 100644
--- a/drivers/hid/usbhid/hid-pidff.c
+++ b/drivers/hid/usbhid/hid-pidff.c
@@ -397,7 +397,6 @@ static void pidff_set_condition_report(struct pidff_device *pidff,
                          effect->u.condition[i].left_saturation);
                pidff_set(&pidff->set_condition[PID_DEAD_BAND],
                          effect->u.condition[i].deadband);
-                usbhid_wait_io(pidff->hid);
                usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION],
                                  USB_DIR_OUT);
        }
@@ -512,7 +511,6 @@ static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)
                pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;
        }
-        usbhid_wait_io(pidff->hid);
        usbhid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
                          USB_DIR_OUT);
 }
@@ -548,6 +546,9 @@ static int pidff_erase_effect(struct input_dev *dev, int effect_id)
        int pid_id = pidff->pid_id[effect_id];
        debug("starting to erase %d/%d", effect_id, pidff->pid_id[effect_id]);
+        /* Wait for the queue to clear. We do not want a full fifo to
+           prevent the effect removal. */
+        usbhid_wait_io(pidff->hid);
        pidff_playback_pid(pidff, pid_id, 0);
        pidff_erase_pid(pidff, pid_id);
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index b15f88249639..47ebe045f9b5 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -17,412 +17,7 @@
 #include <linux/hid.h>
-#define USB_VENDOR_ID_A4TECH            0x09da
+#include "../hid-ids.h"
-#define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
-#define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
-#define USB_VENDOR_ID_AASHIMA           0x06d6
-#define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
-#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
-#define USB_VENDOR_ID_ACECAD            0x0460
-#define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
-#define USB_DEVICE_ID_ACECAD_302        0x0008
-#define USB_VENDOR_ID_ADS_TECH          0x06e1
-#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X     0xa155
-#define USB_VENDOR_ID_AFATECH           0x15a4
-#define USB_DEVICE_ID_AFATECH_AF9016    0x9016
-#define USB_VENDOR_ID_AIPTEK            0x08ca
-#define USB_DEVICE_ID_AIPTEK_01         0x0001
-#define USB_DEVICE_ID_AIPTEK_10         0x0010
-#define USB_DEVICE_ID_AIPTEK_20         0x0020
-#define USB_DEVICE_ID_AIPTEK_21         0x0021
-#define USB_DEVICE_ID_AIPTEK_22         0x0022
-#define USB_DEVICE_ID_AIPTEK_23         0x0023
-#define USB_DEVICE_ID_AIPTEK_24         0x0024
-#define USB_VENDOR_ID_AIRCABLE          0x16CA
-#define USB_DEVICE_ID_AIRCABLE1         0x1502
-#define USB_VENDOR_ID_ALCOR             0x058f
-#define USB_DEVICE_ID_ALCOR_USBRS232    0x9720
-#define USB_VENDOR_ID_ALPS              0x0433
-#define USB_DEVICE_ID_IBM_GAMEPAD       0x1101
-#define USB_VENDOR_ID_APPLE             0x05ac
-#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
-#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
-#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
-#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
-#define USB_DEVICE_ID_APPLE_GEYSER_ISO  0x0215
-#define USB_DEVICE_ID_APPLE_GEYSER_JIS  0x0216
-#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI        0x0217
-#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218
-#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219
-#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI        0x021a
-#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
-#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
-#define USB_DEVICE_ID_APPLE_ALU_ANSI    0x0220
-#define USB_DEVICE_ID_APPLE_ALU_ISO     0x0221
-#define USB_DEVICE_ID_APPLE_ALU_JIS     0x0222
-#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
-#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
-#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
-#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI    0x0229
-#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO     0x022a
-#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS     0x022b
-#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI  0x022c
-#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO   0x022d
-#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS   0x022e
-#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
-#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
-#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
-#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
-#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
-#define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
-#define USB_VENDOR_ID_ASUS              0x0b05
-#define USB_DEVICE_ID_ASUS_LCM          0x1726
-#define USB_VENDOR_ID_ATEN              0x0557
-#define USB_DEVICE_ID_ATEN_UC100KM      0x2004
-#define USB_DEVICE_ID_ATEN_CS124U       0x2202
-#define USB_DEVICE_ID_ATEN_2PORTKVM     0x2204
-#define USB_DEVICE_ID_ATEN_4PORTKVM     0x2205
-#define USB_DEVICE_ID_ATEN_4PORTKVMC    0x2208
-#define USB_VENDOR_ID_BELKIN           0x050d
-#define USB_DEVICE_ID_FLIP_KVM         0x3201
-#define USB_VENDOR_ID_BERKSHIRE         0x0c98
-#define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
-#define USB_VENDOR_ID_CHERRY            0x046a
-#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
-#define USB_VENDOR_ID_CHIC              0x05fe
-#define USB_DEVICE_ID_CHIC_GAMEPAD      0x0014
-#define USB_VENDOR_ID_CIDC              0x1677
-#define USB_VENDOR_ID_CMEDIA            0x0d8c
-#define USB_DEVICE_ID_CM109             0x000e
-#define USB_VENDOR_ID_CODEMERCS         0x07c0
-#define USB_DEVICE_ID_CODEMERCS_IOW_FIRST       0x1500
-#define USB_DEVICE_ID_CODEMERCS_IOW_LAST        0x15ff
-#define USB_VENDOR_ID_CYGNAL            0x10c4
-#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X       0x818a
-#define USB_VENDOR_ID_CYPRESS           0x04b4
-#define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
-#define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
-#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
-#define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
-#define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
-#define USB_VENDOR_ID_DELL              0x413c
-#define USB_DEVICE_ID_DELL_W7658        0x2005
-#define USB_VENDOR_ID_DELORME           0x1163
-#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
-#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
-#define USB_VENDOR_ID_DMI               0x0c0b
-#define USB_DEVICE_ID_DMI_ENC           0x5fab
-#define USB_VENDOR_ID_ELO               0x04E7
-#define USB_DEVICE_ID_ELO_TS2700        0x0020
-#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
-#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
-#define USB_VENDOR_ID_EZKEY             0x0518
-#define USB_DEVICE_ID_BTC_8193          0x0002
-#define USB_VENDOR_ID_GAMERON           0x0810
-#define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR  0x0001
-#define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
-#define USB_VENDOR_ID_GLAB              0x06c2
-#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
-#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039
-#define USB_DEVICE_ID_0_0_4_IF_KIT      0x0040
-#define USB_DEVICE_ID_0_16_16_IF_KIT    0x0044
-#define USB_DEVICE_ID_8_8_8_IF_KIT      0x0045
-#define USB_DEVICE_ID_0_8_7_IF_KIT      0x0051
-#define USB_DEVICE_ID_0_8_8_IF_KIT      0x0053
-#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL      0x0058
-#define USB_VENDOR_ID_GOTOP             0x08f2
-#define USB_DEVICE_ID_SUPER_Q2          0x007f
-#define USB_DEVICE_ID_GOGOPEN           0x00ce
-#define USB_DEVICE_ID_PENPOWER          0x00f4
-#define USB_VENDOR_ID_GRETAGMACBETH     0x0971
-#define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
-#define USB_VENDOR_ID_GRIFFIN           0x077d
-#define USB_DEVICE_ID_POWERMATE         0x0410
-#define USB_DEVICE_ID_SOUNDKNOB         0x04AA
-#define USB_VENDOR_ID_GTCO              0x078c
-#define USB_DEVICE_ID_GTCO_90           0x0090
-#define USB_DEVICE_ID_GTCO_100          0x0100
-#define USB_DEVICE_ID_GTCO_101          0x0101
-#define USB_DEVICE_ID_GTCO_103          0x0103
-#define USB_DEVICE_ID_GTCO_104          0x0104
-#define USB_DEVICE_ID_GTCO_105          0x0105
-#define USB_DEVICE_ID_GTCO_106          0x0106
-#define USB_DEVICE_ID_GTCO_107          0x0107
-#define USB_DEVICE_ID_GTCO_108          0x0108
-#define USB_DEVICE_ID_GTCO_200          0x0200
-#define USB_DEVICE_ID_GTCO_201          0x0201
-#define USB_DEVICE_ID_GTCO_202          0x0202
-#define USB_DEVICE_ID_GTCO_203          0x0203
-#define USB_DEVICE_ID_GTCO_204          0x0204
-#define USB_DEVICE_ID_GTCO_205          0x0205
-#define USB_DEVICE_ID_GTCO_206          0x0206
-#define USB_DEVICE_ID_GTCO_207          0x0207
-#define USB_DEVICE_ID_GTCO_300          0x0300
-#define USB_DEVICE_ID_GTCO_301          0x0301
-#define USB_DEVICE_ID_GTCO_302          0x0302
-#define USB_DEVICE_ID_GTCO_303          0x0303
-#define USB_DEVICE_ID_GTCO_304          0x0304
-#define USB_DEVICE_ID_GTCO_305          0x0305
-#define USB_DEVICE_ID_GTCO_306          0x0306
-#define USB_DEVICE_ID_GTCO_307          0x0307
-#define USB_DEVICE_ID_GTCO_308          0x0308
-#define USB_DEVICE_ID_GTCO_309          0x0309
-#define USB_DEVICE_ID_GTCO_400          0x0400
-#define USB_DEVICE_ID_GTCO_401          0x0401
-#define USB_DEVICE_ID_GTCO_402          0x0402
-#define USB_DEVICE_ID_GTCO_403          0x0403
-#define USB_DEVICE_ID_GTCO_404          0x0404
-#define USB_DEVICE_ID_GTCO_405          0x0405
-#define USB_DEVICE_ID_GTCO_500          0x0500
-#define USB_DEVICE_ID_GTCO_501          0x0501
-#define USB_DEVICE_ID_GTCO_502          0x0502
-#define USB_DEVICE_ID_GTCO_503          0x0503
-#define USB_DEVICE_ID_GTCO_504          0x0504
-#define USB_DEVICE_ID_GTCO_1000         0x1000
-#define USB_DEVICE_ID_GTCO_1001         0x1001
-#define USB_DEVICE_ID_GTCO_1002         0x1002
-#define USB_DEVICE_ID_GTCO_1003         0x1003
-#define USB_DEVICE_ID_GTCO_1004         0x1004
-#define USB_DEVICE_ID_GTCO_1005         0x1005
-#define USB_DEVICE_ID_GTCO_1006         0x1006
-#define USB_DEVICE_ID_GTCO_1007         0x1007
-#define USB_VENDOR_ID_HAPP              0x078b
-#define USB_DEVICE_ID_UGCI_DRIVING      0x0010
-#define USB_DEVICE_ID_UGCI_FLYING       0x0020
-#define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
-#define USB_VENDOR_ID_IMATION           0x0718
-#define USB_DEVICE_ID_DISC_STAKKA       0xd000
-#define USB_VENDOR_ID_KBGEAR            0x084e
-#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
-#define USB_VENDOR_ID_LD                0x0f11
-#define USB_DEVICE_ID_LD_CASSY          0x1000
-#define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
-#define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
-#define USB_DEVICE_ID_LD_JWM            0x1080
-#define USB_DEVICE_ID_LD_DMMP           0x1081
-#define USB_DEVICE_ID_LD_UMIP           0x1090
-#define USB_DEVICE_ID_LD_XRAY1          0x1100
-#define USB_DEVICE_ID_LD_XRAY2          0x1101
-#define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
-#define USB_DEVICE_ID_LD_COM3LAB        0x2000
-#define USB_DEVICE_ID_LD_TELEPORT       0x2010
-#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
-#define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
-#define USB_DEVICE_ID_LD_MACHINETEST    0x2040
-#define USB_VENDOR_ID_LOGITECH          0x046d
-#define USB_DEVICE_ID_LOGITECH_LX3      0xc044
-#define USB_DEVICE_ID_LOGITECH_V150     0xc047
-#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
-#define USB_DEVICE_ID_LOGITECH_HARMONY  0xc110
-#define USB_DEVICE_ID_LOGITECH_HARMONY_2 0xc111
-#define USB_DEVICE_ID_LOGITECH_HARMONY_3 0xc112
-#define USB_DEVICE_ID_LOGITECH_HARMONY_4 0xc113
-#define USB_DEVICE_ID_LOGITECH_HARMONY_5 0xc114
-#define USB_DEVICE_ID_LOGITECH_HARMONY_6 0xc115
-#define USB_DEVICE_ID_LOGITECH_HARMONY_7 0xc116
-#define USB_DEVICE_ID_LOGITECH_HARMONY_8 0xc117
-#define USB_DEVICE_ID_LOGITECH_HARMONY_9 0xc118
-#define USB_DEVICE_ID_LOGITECH_HARMONY_10 0xc119
-#define USB_DEVICE_ID_LOGITECH_HARMONY_11 0xc11a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_12 0xc11b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_13 0xc11c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_14 0xc11d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_15 0xc11e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_16 0xc11f
-#define USB_DEVICE_ID_LOGITECH_HARMONY_17 0xc120
-#define USB_DEVICE_ID_LOGITECH_HARMONY_18 0xc121
-#define USB_DEVICE_ID_LOGITECH_HARMONY_19 0xc122
-#define USB_DEVICE_ID_LOGITECH_HARMONY_20 0xc123
-#define USB_DEVICE_ID_LOGITECH_HARMONY_21 0xc124
-#define USB_DEVICE_ID_LOGITECH_HARMONY_22 0xc125
-#define USB_DEVICE_ID_LOGITECH_HARMONY_23 0xc126
-#define USB_DEVICE_ID_LOGITECH_HARMONY_24 0xc127
-#define USB_DEVICE_ID_LOGITECH_HARMONY_25 0xc128
-#define USB_DEVICE_ID_LOGITECH_HARMONY_26 0xc129
-#define USB_DEVICE_ID_LOGITECH_HARMONY_27 0xc12a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_28 0xc12b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_29 0xc12c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_30 0xc12d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_31 0xc12e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_32 0xc12f
-#define USB_DEVICE_ID_LOGITECH_HARMONY_33 0xc130
-#define USB_DEVICE_ID_LOGITECH_HARMONY_34 0xc131
-#define USB_DEVICE_ID_LOGITECH_HARMONY_35 0xc132
-#define USB_DEVICE_ID_LOGITECH_HARMONY_36 0xc133
-#define USB_DEVICE_ID_LOGITECH_HARMONY_37 0xc134
-#define USB_DEVICE_ID_LOGITECH_HARMONY_38 0xc135
-#define USB_DEVICE_ID_LOGITECH_HARMONY_39 0xc136
-#define USB_DEVICE_ID_LOGITECH_HARMONY_40 0xc137
-#define USB_DEVICE_ID_LOGITECH_HARMONY_41 0xc138
-#define USB_DEVICE_ID_LOGITECH_HARMONY_42 0xc139
-#define USB_DEVICE_ID_LOGITECH_HARMONY_43 0xc13a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_44 0xc13b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_45 0xc13c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_46 0xc13d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_47 0xc13e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_48 0xc13f
-#define USB_DEVICE_ID_LOGITECH_HARMONY_49 0xc140
-#define USB_DEVICE_ID_LOGITECH_HARMONY_50 0xc141
-#define USB_DEVICE_ID_LOGITECH_HARMONY_51 0xc142
-#define USB_DEVICE_ID_LOGITECH_HARMONY_52 0xc143
-#define USB_DEVICE_ID_LOGITECH_HARMONY_53 0xc144
-#define USB_DEVICE_ID_LOGITECH_HARMONY_54 0xc145
-#define USB_DEVICE_ID_LOGITECH_HARMONY_55 0xc146
-#define USB_DEVICE_ID_LOGITECH_HARMONY_56 0xc147
-#define USB_DEVICE_ID_LOGITECH_HARMONY_57 0xc148
-#define USB_DEVICE_ID_LOGITECH_HARMONY_58 0xc149
-#define USB_DEVICE_ID_LOGITECH_HARMONY_59 0xc14a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_60 0xc14b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_61 0xc14c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_62 0xc14d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_63 0xc14e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_64 0xc14f
-#define USB_DEVICE_ID_LOGITECH_EXTREME_3D       0xc215
-#define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
-#define USB_DEVICE_ID_LOGITECH_ELITE_KBD        0xc30a
-#define USB_DEVICE_ID_LOGITECH_KBD      0xc311
-#define USB_DEVICE_ID_S510_RECEIVER     0xc50c
-#define USB_DEVICE_ID_S510_RECEIVER_2   0xc517
-#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500   0xc512
-#define USB_DEVICE_ID_MX3000_RECEIVER   0xc513
-#define USB_DEVICE_ID_DINOVO_DESKTOP    0xc704
-#define USB_DEVICE_ID_DINOVO_EDGE       0xc714
-#define USB_DEVICE_ID_DINOVO_MINI       0xc71f
-#define USB_VENDOR_ID_MCC               0x09db
-#define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
-#define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
-#define USB_VENDOR_ID_MGE               0x0463
-#define USB_DEVICE_ID_MGE_UPS           0xffff
-#define USB_DEVICE_ID_MGE_UPS1          0x0001
-#define USB_VENDOR_ID_MICROCHIP         0x04d8
-#define USB_DEVICE_ID_PICKIT1           0x0032
-#define USB_DEVICE_ID_PICKIT2           0x0033
-#define USB_VENDOR_ID_MICROSOFT         0x045e
-#define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
-#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
-#define USB_DEVICE_ID_DESKTOP_RECV_1028 0x00f9
-#define USB_DEVICE_ID_MS_NE4K           0x00db
-#define USB_DEVICE_ID_MS_LK6K           0x00f9
-#define USB_VENDOR_ID_MONTEREY          0x0566
-#define USB_DEVICE_ID_GENIUS_KB29E      0x3004
-#define USB_VENDOR_ID_NCR               0x0404
-#define USB_DEVICE_ID_NCR_FIRST         0x0300
-#define USB_DEVICE_ID_NCR_LAST          0x03ff
-#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
-#define USB_DEVICE_ID_N_S_HARMONY       0xc359
-#define USB_VENDOR_ID_NATSU             0x08b7
-#define USB_DEVICE_ID_NATSU_GAMEPAD     0x0001
-#define USB_VENDOR_ID_NEC               0x073e
-#define USB_DEVICE_ID_NEC_USB_GAME_PAD  0x0301
-#define USB_VENDOR_ID_ONTRAK            0x0a07
-#define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
-#define USB_VENDOR_ID_PANJIT            0x134c
-#define USB_VENDOR_ID_PANTHERLORD       0x0810
-#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
-#define USB_VENDOR_ID_PETALYNX          0x18b1
-#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE    0x0037
-#define USB_VENDOR_ID_PLAYDOTCOM        0x0b43
-#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII      0x0003
-#define USB_VENDOR_ID_SAITEK            0x06a3
-#define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
-#define USB_VENDOR_ID_SAMSUNG           0x0419
-#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
-#define USB_VENDOR_ID_SONY                      0x054c
-#define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
-#define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
-#define USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD       0x0038
-#define USB_VENDOR_ID_SUN               0x0430
-#define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
-#define USB_VENDOR_ID_SUNPLUS           0x04fc
-#define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
-#define USB_VENDOR_ID_TOPMAX            0x0663
-#define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
-#define USB_VENDOR_ID_TURBOX            0x062a
-#define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
-#define USB_VENDOR_ID_VERNIER           0x08f7
-#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
-#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
-#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
-#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
-#define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
-#define USB_VENDOR_ID_WACOM             0x056a
-#define USB_VENDOR_ID_WISEGROUP         0x0925
-#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101
-#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104
-#define USB_DEVICE_ID_8_8_4_IF_KIT      0x8201
-#define USB_DEVICE_ID_QUAD_USB_JOYPAD   0x8800
-#define USB_DEVICE_ID_DUAL_USB_JOYPAD   0x8866
-#define USB_VENDOR_ID_WISEGROUP_LTD     0x6677
-#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
-#define USB_VENDOR_ID_YEALINK           0x6993
-#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K       0xb001
-#define USB_VENDOR_ID_KYE               0x0458
-#define USB_DEVICE_ID_KYE_GPEN_560      0x5003
 /*
 * Alphabetically sorted blacklist by quirk type.
@@ -433,18 +28,10 @@ static const struct hid_blacklist {
        __u16 idProduct;
        __u32 quirks;
 } hid_blacklist[] = {
-        { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_7 },
-        { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D, HID_QUIRK_2WHEEL_MOUSE_HACK_B8 },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_5 },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER, HID_QUIRK_BAD_RELATIVE_KEYS },
        { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD, HID_QUIRK_BADPAD },
        { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR, HID_QUIRK_BADPAD },
        { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },
        { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
-        { USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR, HID_QUIRK_MULTI_INPUT },
        { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
        { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
        { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
@@ -453,169 +40,11 @@ static const struct hid_blacklist {
        { USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD, HID_QUIRK_BADPAD },
        { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP, HID_QUIRK_DUPLICATE_USAGES },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE, HID_QUIRK_DUPLICATE_USAGES },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI, HID_QUIRK_DUPLICATE_USAGES },
        { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
-        { USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM, HID_QUIRK_HIDDEV },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT },
-        { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV, HID_QUIRK_HIDINPUT },
-        { USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193, HID_QUIRK_HWHEEL_WHEEL_INVERT },
-        { USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM, HID_QUIRK_IGNORE},
-        { USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CIDC, 0x0103, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0001, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0002, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0003, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0004, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0001, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0002, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0003, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0004, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD, HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL | HID_QUIRK_LOGITECH_EXPANDED_KEYMAP },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500, HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL | HID_QUIRK_LOGITECH_EXPANDED_KEYMAP },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_LX3, HID_QUIRK_INVERT_HWHEEL },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150, HID_QUIRK_INVERT_HWHEEL },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K, HID_QUIRK_MICROSOFT_KEYS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K, HID_QUIRK_MICROSOFT_KEYS },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL },
        { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
        { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
-        { USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER, HID_QUIRK_SONY_PS3_CONTROLLER | HID_QUIRK_HIDDEV },
        { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },
@@ -623,144 +52,13 @@ static const struct hid_blacklist {
        { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET },
        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
        { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD | HID_QUIRK_IGNORE_MOUSE},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS, HID_QUIRK_APPLE_HAS_FN  | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658, HID_QUIRK_RESET_LEDS },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD, HID_QUIRK_RESET_LEDS },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_6, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_7, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_8, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_9, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_10, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_11, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_12, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_13, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_14, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_15, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_16, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_17, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_18, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_19, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_21, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_22, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_23, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_24, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_25, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_26, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_27, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_28, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_29, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_31, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_32, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_33, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_34, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_35, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_36, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_37, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_38, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_39, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_40, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_41, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_42, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_43, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_44, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_45, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_46, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_47, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_48, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_49, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_50, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_51, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_52, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_53, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_54, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_55, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_56, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_57, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_58, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_59, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_60, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_61, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_62, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_63, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_64, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560, HID_QUIRK_IGNORE },
-        { 0, 0 }
-};
-/* Quirks for devices which require report descriptor fixup go here */
-static const struct hid_rdesc_blacklist {
-        __u16 idVendor;
-        __u16 idProduct;
-        __u32 quirks;
-} hid_rdesc_blacklist[] = {
-        { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_RDESC_CYMOTION },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER, HID_QUIRK_RDESC_LOGITECH },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER, HID_QUIRK_RDESC_LOGITECH },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2, HID_QUIRK_RDESC_LOGITECH },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_DESKTOP_RECV_1028, HID_QUIRK_RDESC_MICROSOFT_RECV_1028 },
-        { USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E, HID_QUIRK_RDESC_BUTTON_CONSUMER },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_RDESC_MACBOOK_JIS },
-        { USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_RDESC_PETALYNX },
-        { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_RDESC_SAMSUNG_REMOTE },
-        { USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP, HID_QUIRK_RDESC_SUNPLUS_WDESKTOP },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1, HID_QUIRK_RDESC_SWAPPED_MIN_MAX },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2, HID_QUIRK_RDESC_SWAPPED_MIN_MAX },
        { 0, 0 }
 };
@@ -974,16 +272,6 @@ u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct)
        u32 quirks = 0;
        const struct hid_blacklist *bl_entry = NULL;
-        /* Ignore all Wacom devices */
-        if (idVendor == USB_VENDOR_ID_WACOM)
-                return HID_QUIRK_IGNORE;
-        /* ignore all Code Mercenaries IOWarrior devices */
-        if (idVendor == USB_VENDOR_ID_CODEMERCS)
-                if (idProduct >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
-                                idProduct <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
-                        return HID_QUIRK_IGNORE;
        /* NCR devices must not be queried for reports */
        if (idVendor == USB_VENDOR_ID_NCR &&
                        idProduct >= USB_DEVICE_ID_NCR_FIRST &&
@@ -1002,221 +290,3 @@ u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct)
 }
 EXPORT_SYMBOL_GPL(usbhid_lookup_quirk);
-/*
- * Cherry Cymotion keyboard have an invalid HID report descriptor,
- * that needs fixing before we can parse it.
- */
-static void usbhid_fixup_cymotion_descriptor(char *rdesc, int rsize)
-{
-        if (rsize >= 17 && rdesc[11] == 0x3c && rdesc[12] == 0x02) {
-                printk(KERN_INFO "Fixing up Cherry Cymotion report descriptor\n");
-                rdesc[11] = rdesc[16] = 0xff;
-                rdesc[12] = rdesc[17] = 0x03;
-        }
-}
-/*
- * Certain Logitech keyboards send in report #3 keys which are far
- * above the logical maximum described in descriptor. This extends
- * the original value of 0x28c of logical maximum to 0x104d
- */
-static void usbhid_fixup_logitech_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 90 && rdesc[83] == 0x26
-                        && rdesc[84] == 0x8c
-                        && rdesc[85] == 0x02) {
-                printk(KERN_INFO "Fixing up Logitech keyboard report descriptor\n");
-                rdesc[84] = rdesc[89] = 0x4d;
-                rdesc[85] = rdesc[90] = 0x10;
-        }
-}
-static void usbhid_fixup_sunplus_wdesktop(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 107 && rdesc[104] == 0x26
-                         && rdesc[105] == 0x80
-                         && rdesc[106] == 0x03) {
-                printk(KERN_INFO "Fixing up Sunplus Wireless Desktop report descriptor\n");
-                rdesc[105] = rdesc[110] = 0x03;
-                rdesc[106] = rdesc[111] = 0x21;
-        }
-}
-/*
- * Samsung IrDA remote controller (reports as Cypress USB Mouse).
- *
- * Vendor specific report #4 has a size of 48 bit,
- * and therefore is not accepted when inspecting the descriptors.
- * As a workaround we reinterpret the report as:
- *   Variable type, count 6, size 8 bit, log. maximum 255
- * The burden to reconstruct the data is moved into user space.
- */
-static void usbhid_fixup_samsung_irda_descriptor(unsigned char *rdesc,
-                                                  int rsize)
-{
-        if (rsize >= 182 && rdesc[175] == 0x25
-                         && rdesc[176] == 0x40
-                         && rdesc[177] == 0x75
-                         && rdesc[178] == 0x30
-                         && rdesc[179] == 0x95
-                         && rdesc[180] == 0x01
-                         && rdesc[182] == 0x40) {
-                printk(KERN_INFO "Fixing up Samsung IrDA report descriptor\n");
-                rdesc[176] = 0xff;
-                rdesc[178] = 0x08;
-                rdesc[180] = 0x06;
-                rdesc[182] = 0x42;
-        }
-}
-/* Petalynx Maxter Remote has maximum for consumer page set too low */
-static void usbhid_fixup_petalynx_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 60 && rdesc[39] == 0x2a
-                        && rdesc[40] == 0xf5
-                        && rdesc[41] == 0x00
-                        && rdesc[59] == 0x26
-                        && rdesc[60] == 0xf9
-                        && rdesc[61] == 0x00) {
-                printk(KERN_INFO "Fixing up Petalynx Maxter Remote report descriptor\n");
-                rdesc[60] = 0xfa;
-                rdesc[40] = 0xfa;
-        }
-}
-/*
- * Some USB barcode readers from cypress have usage min and usage max in
- * the wrong order
- */
-static void usbhid_fixup_cypress_descriptor(unsigned char *rdesc, int rsize)
-{
-        short fixed = 0;
-        int i;
-        for (i = 0; i < rsize - 4; i++) {
-                if (rdesc[i] == 0x29 && rdesc [i+2] == 0x19) {
-                        unsigned char tmp;
-                        rdesc[i] = 0x19; rdesc[i+2] = 0x29;
-                        tmp = rdesc[i+3];
-                        rdesc[i+3] = rdesc[i+1];
-                        rdesc[i+1] = tmp;
-                }
-        }
-        if (fixed)
-                printk(KERN_INFO "Fixing up Cypress report descriptor\n");
-}
-/*
- * MacBook JIS keyboard has wrong logical maximum
- */
-static void usbhid_fixup_macbook_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 60 && rdesc[53] == 0x65
-                        && rdesc[59] == 0x65) {
-                printk(KERN_INFO "Fixing up MacBook JIS keyboard report descriptor\n");
-                rdesc[53] = rdesc[59] = 0xe7;
-        }
-}
-static void usbhid_fixup_button_consumer_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 30 && rdesc[29] == 0x05
-                        && rdesc[30] == 0x09) {
-                printk(KERN_INFO "Fixing up button/consumer in HID report descriptor\n");
-                rdesc[30] = 0x0c;
-        }
-}
-/*
- * Microsoft Wireless Desktop Receiver (Model 1028) has several
- * 'Usage Min/Max' where it ought to have 'Physical Min/Max'
- */
-static void usbhid_fixup_microsoft_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize == 571 && rdesc[284] == 0x19
-                         && rdesc[286] == 0x2a
-                         && rdesc[304] == 0x19
-                         && rdesc[306] == 0x29
-                         && rdesc[352] == 0x1a
-                         && rdesc[355] == 0x2a
-                         && rdesc[557] == 0x19
-                         && rdesc[559] == 0x29) {
-                printk(KERN_INFO "Fixing up Microsoft Wireless Receiver Model 1028 report descriptor\n");
-                rdesc[284] = rdesc[304] = rdesc[557] = 0x35;
-                rdesc[352] = 0x36;
-                rdesc[286] = rdesc[355] = 0x46;
-                rdesc[306] = rdesc[559] = 0x45;
-        }
-}
-static void __usbhid_fixup_report_descriptor(__u32 quirks, char *rdesc, unsigned rsize)
-{
-        if ((quirks & HID_QUIRK_RDESC_CYMOTION))
-                usbhid_fixup_cymotion_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_LOGITECH)
-                usbhid_fixup_logitech_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_SWAPPED_MIN_MAX)
-                usbhid_fixup_cypress_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_PETALYNX)
-                usbhid_fixup_petalynx_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_MACBOOK_JIS)
-                usbhid_fixup_macbook_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_BUTTON_CONSUMER)
-                usbhid_fixup_button_consumer_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_SAMSUNG_REMOTE)
-                usbhid_fixup_samsung_irda_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_MICROSOFT_RECV_1028)
-                usbhid_fixup_microsoft_descriptor(rdesc, rsize);
-        if (quirks & HID_QUIRK_RDESC_SUNPLUS_WDESKTOP)
-                usbhid_fixup_sunplus_wdesktop(rdesc, rsize);
-}
-/**
- * usbhid_fixup_report_descriptor: check if report descriptor needs fixup
- *
- * Description:
- *      Walks the hid_rdesc_blacklist[] array and checks whether the device
- *      is known to have broken report descriptor that needs to be fixed up
- *      prior to entering the HID parser
- *
- * Returns: nothing
- */
-void usbhid_fixup_report_descriptor(const u16 idVendor, const u16 idProduct,
-                                    char *rdesc, unsigned rsize, char **quirks_param)
-{
-        int n, m;
-        u16 paramVendor, paramProduct;
-        u32 quirks;
-        /* static rdesc quirk entries */
-        for (n = 0; hid_rdesc_blacklist[n].idVendor; n++)
-                if (hid_rdesc_blacklist[n].idVendor == idVendor &&
-                                hid_rdesc_blacklist[n].idProduct == idProduct)
-                        __usbhid_fixup_report_descriptor(hid_rdesc_blacklist[n].quirks,
-                                        rdesc, rsize);
-        /* runtime rdesc quirk entries handling */
-        for (n = 0; quirks_param[n] && n < MAX_USBHID_BOOT_QUIRKS; n++) {
-                m = sscanf(quirks_param[n], "0x%hx:0x%hx:0x%x",
-                                &paramVendor, &paramProduct, &quirks);
-                if (m != 3)
-                        printk(KERN_WARNING
-                                "Could not parse HID quirk module param %s\n",
-                                quirks_param[n]);
-                else if (paramVendor == idVendor && paramProduct == idProduct)
-                        __usbhid_fixup_report_descriptor(quirks, rdesc, rsize);
-        }
-}
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 842e9edb888e..babd65dd46ad 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -790,21 +790,23 @@ static struct usb_class_driver hiddev_class = {
 /*
 * This is where hid.c calls us to connect a hid device to the hiddev driver
 */
-int hiddev_connect(struct hid_device *hid)
+int hiddev_connect(struct hid_device *hid, unsigned int force)
 {
        struct hiddev *hiddev;
        struct usbhid_device *usbhid = hid->driver_data;
-        int i;
        int retval;
-        for (i = 0; i < hid->maxcollection; i++)
+        if (!force) {
-                if (hid->collection[i].type ==
+                unsigned int i;
-                    HID_COLLECTION_APPLICATION &&
+                for (i = 0; i < hid->maxcollection; i++)
-                    !IS_INPUT_APPLICATION(hid->collection[i].usage))
+                        if (hid->collection[i].type ==
-                        break;
+                            HID_COLLECTION_APPLICATION &&
+                            !IS_INPUT_APPLICATION(hid->collection[i].usage))
+                                break;
-        if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDDEV) == 0)
+                if (i == hid->maxcollection)
-                return -1;
+                        return -1;
+        }
        if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
                return -1;
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 62d2d7c925bd..abedb13c623e 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -67,7 +67,7 @@ struct usbhid_device {
        spinlock_t ctrllock;                                            /* Control fifo spinlock */
        struct urb *urbout;                                             /* Output URB */
-        struct hid_report *out[HID_CONTROL_FIFO_SIZE];                  /* Output pipe fifo */
+        struct hid_output_fifo out[HID_CONTROL_FIFO_SIZE];              /* Output pipe fifo */
        unsigned char outhead, outtail;                                 /* Output pipe fifo head & tail */
        char *outbuf;                                                   /* Output buffer */
        dma_addr_t outbuf_dma;                                          /* Output buffer dma */
@@ -82,7 +82,7 @@ struct usbhid_device {
 };
 #define hid_to_usb_dev(hid_dev) \
-        container_of(hid_dev->dev->parent, struct usb_device, dev)
+        container_of(hid_dev->dev.parent->parent, struct usb_device, dev)
 #endif
diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c
index 0caaafe01843..b342926dd7fc 100644
--- a/drivers/hid/usbhid/usbkbd.c
+++ b/drivers/hid/usbhid/usbkbd.c
@@ -105,14 +105,16 @@ static void usb_kbd_irq(struct urb *urb)
                        if (usb_kbd_keycode[kbd->old[i]])
                                input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
                        else
-                                info("Unknown key (scancode %#x) released.", kbd->old[i]);
+                                dev_info(&urb->dev->dev,
+                                                "Unknown key (scancode %#x) released.\n", kbd->old[i]);
                }
                if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
                        if (usb_kbd_keycode[kbd->new[i]])
                                input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
                        else
-                                info("Unknown key (scancode %#x) pressed.", kbd->new[i]);
+                                dev_info(&urb->dev->dev,
+                                                "Unknown key (scancode %#x) released.\n", kbd->new[i]);
                }
        }
@@ -159,7 +161,8 @@ static void usb_kbd_led(struct urb *urb)
        struct usb_kbd *kbd = urb->context;
        if (urb->status)
-                warn("led urb status %d received", urb->status);
+                dev_warn(&urb->dev->dev, "led urb status %d received\n",
+                         urb->status);
        if (*(kbd->leds) == kbd->newleds)
                return;
@@ -352,7 +355,8 @@ static int __init usb_kbd_init(void)
 {
        int result = usb_register(&usb_kbd_driver);
        if (result == 0)
-                info(DRIVER_VERSION ":" DRIVER_DESC);
+                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+                                DRIVER_DESC "\n");
        return result;
 }
diff --git a/drivers/hid/usbhid/usbmouse.c b/drivers/hid/usbhid/usbmouse.c
index 35689ef172cc..72ab4b268096 100644
--- a/drivers/hid/usbhid/usbmouse.c
+++ b/drivers/hid/usbhid/usbmouse.c
@@ -31,6 +31,11 @@
 #include <linux/usb/input.h>
 #include <linux/hid.h>
+/* for apple IDs */
+#ifdef CONFIG_USB_HID_MODULE
+#include "../hid-ids.h"
+#endif
 /*
 * Version Information
 */
@@ -240,7 +245,8 @@ static int __init usb_mouse_init(void)
 {
        int retval = usb_register(&usb_mouse_driver);
        if (retval == 0)
-                info(DRIVER_VERSION ":" DRIVER_DESC);
+                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+                                DRIVER_DESC "\n");
        return retval;
 }
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
index cdb8311e4ef7..27a5d397f9a1 100644
--- a/drivers/hwmon/dme1737.c
+++ b/drivers/hwmon/dme1737.c
@@ -175,11 +175,11 @@ static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 * Data structures and manipulation thereof
 * --------------------------------------------------------------------- */
-/* For ISA chips, we abuse the i2c_client addr and name fields. We also use
-   the driver field to differentiate between I2C and ISA chips. */
 struct dme1737_data {
-        struct i2c_client client;
+        struct i2c_client *client;      /* for I2C devices only */
        struct device *hwmon_dev;
+        const char *name;
+        unsigned int addr;              /* for ISA devices only */
        struct mutex update_lock;
        int valid;                      /* !=0 if following fields are valid */
@@ -512,11 +512,12 @@ static inline int PWM_OFF_TO_REG(int val, int ix, int reg)
 * before calling dme1737_read or dme1737_write.
 * --------------------------------------------------------------------- */
-static u8 dme1737_read(struct i2c_client *client, u8 reg)
+static u8 dme1737_read(const struct dme1737_data *data, u8 reg)
 {
+        struct i2c_client *client = data->client;
        s32 val;
-        if (client->driver) { /* I2C device */
+        if (client) { /* I2C device */
                val = i2c_smbus_read_byte_data(client, reg);
                if (val < 0) {
@@ -525,18 +526,19 @@ static u8 dme1737_read(struct i2c_client *client, u8 reg)
                                 "maintainer.\n", reg);
                }
        } else { /* ISA device */
-                outb(reg, client->addr);
+                outb(reg, data->addr);
-                val = inb(client->addr + 1);
+                val = inb(data->addr + 1);
        }
        return val;
 }
-static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val)
+static s32 dme1737_write(const struct dme1737_data *data, u8 reg, u8 val)
 {
+        struct i2c_client *client = data->client;
        s32 res = 0;
-        if (client->driver) { /* I2C device */
+        if (client) { /* I2C device */
                res = i2c_smbus_write_byte_data(client, reg, val);
                if (res < 0) {
@@ -545,8 +547,8 @@ static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val)
                                 "maintainer.\n", reg);
                }
        } else { /* ISA device */
-                outb(reg, client->addr);
+                outb(reg, data->addr);
-                outb(val, client->addr + 1);
+                outb(val, data->addr + 1);
        }
        return res;
@@ -555,7 +557,6 @@ static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val)
 static struct dme1737_data *dme1737_update_device(struct device *dev)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
        int ix;
        u8 lsb[5];
@@ -563,7 +564,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
        /* Enable a Vbat monitoring cycle every 10 mins */
        if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) {
-                dme1737_write(client, DME1737_REG_CONFIG, dme1737_read(client,
+                dme1737_write(data, DME1737_REG_CONFIG, dme1737_read(data,
                                                DME1737_REG_CONFIG) | 0x10);
                data->last_vbat = jiffies;
        }
@@ -571,7 +572,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
        /* Sample register contents every 1 sec */
        if (time_after(jiffies, data->last_update + HZ) || !data->valid) {
                if (data->type != sch5027) {
-                        data->vid = dme1737_read(client, DME1737_REG_VID) &
+                        data->vid = dme1737_read(data, DME1737_REG_VID) &
                                0x3f;
                }
@@ -580,11 +581,11 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                        /* Voltage inputs are stored as 16 bit values even
                         * though they have only 12 bits resolution. This is
                         * to make it consistent with the temp inputs. */
-                        data->in[ix] = dme1737_read(client,
+                        data->in[ix] = dme1737_read(data,
                                        DME1737_REG_IN(ix)) << 8;
-                        data->in_min[ix] = dme1737_read(client,
+                        data->in_min[ix] = dme1737_read(data,
                                        DME1737_REG_IN_MIN(ix));
-                        data->in_max[ix] = dme1737_read(client,
+                        data->in_max[ix] = dme1737_read(data,
                                        DME1737_REG_IN_MAX(ix));
                }
@@ -595,14 +596,14 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                         * to take advantage of implicit conversions between
                         * register values (2's complement) and temp values
                         * (signed decimal). */
-                        data->temp[ix] = dme1737_read(client,
+                        data->temp[ix] = dme1737_read(data,
                                        DME1737_REG_TEMP(ix)) << 8;
-                        data->temp_min[ix] = dme1737_read(client,
+                        data->temp_min[ix] = dme1737_read(data,
                                        DME1737_REG_TEMP_MIN(ix));
-                        data->temp_max[ix] = dme1737_read(client,
+                        data->temp_max[ix] = dme1737_read(data,
                                        DME1737_REG_TEMP_MAX(ix));
                        if (data->type != sch5027) {
-                                data->temp_offset[ix] = dme1737_read(client,
+                                data->temp_offset[ix] = dme1737_read(data,
                                                DME1737_REG_TEMP_OFFSET(ix));
                        }
                }
@@ -612,7 +613,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                 * which the registers are read (MSB first, then LSB) is
                 * important! */
                for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) {
-                        lsb[ix] = dme1737_read(client,
+                        lsb[ix] = dme1737_read(data,
                                        DME1737_REG_IN_TEMP_LSB(ix));
                }
                for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
@@ -631,19 +632,19 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                        if (!(data->has_fan & (1 << ix))) {
                                continue;
                        }
-                        data->fan[ix] = dme1737_read(client,
+                        data->fan[ix] = dme1737_read(data,
                                        DME1737_REG_FAN(ix));
-                        data->fan[ix] |= dme1737_read(client,
+                        data->fan[ix] |= dme1737_read(data,
                                        DME1737_REG_FAN(ix) + 1) << 8;
-                        data->fan_min[ix] = dme1737_read(client,
+                        data->fan_min[ix] = dme1737_read(data,
                                        DME1737_REG_FAN_MIN(ix));
-                        data->fan_min[ix] |= dme1737_read(client,
+                        data->fan_min[ix] |= dme1737_read(data,
                                        DME1737_REG_FAN_MIN(ix) + 1) << 8;
-                        data->fan_opt[ix] = dme1737_read(client,
+                        data->fan_opt[ix] = dme1737_read(data,
                                        DME1737_REG_FAN_OPT(ix));
                        /* fan_max exists only for fan[5-6] */
                        if (ix > 3) {
-                                data->fan_max[ix - 4] = dme1737_read(client,
+                                data->fan_max[ix - 4] = dme1737_read(data,
                                        DME1737_REG_FAN_MAX(ix));
                        }
                }
@@ -655,63 +656,63 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                        if (!(data->has_pwm & (1 << ix))) {
                                continue;
                        }
-                        data->pwm[ix] = dme1737_read(client,
+                        data->pwm[ix] = dme1737_read(data,
                                        DME1737_REG_PWM(ix));
-                        data->pwm_freq[ix] = dme1737_read(client,
+                        data->pwm_freq[ix] = dme1737_read(data,
                                        DME1737_REG_PWM_FREQ(ix));
                        /* pwm_config and pwm_min exist only for pwm[1-3] */
                        if (ix < 3) {
-                                data->pwm_config[ix] = dme1737_read(client,
+                                data->pwm_config[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_CONFIG(ix));
-                                data->pwm_min[ix] = dme1737_read(client,
+                                data->pwm_min[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_MIN(ix));
                        }
                }
                for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) {
-                        data->pwm_rr[ix] = dme1737_read(client,
+                        data->pwm_rr[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_RR(ix));
                }
                /* Thermal zone registers */
                for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) {
-                        data->zone_low[ix] = dme1737_read(client,
+                        data->zone_low[ix] = dme1737_read(data,
                                        DME1737_REG_ZONE_LOW(ix));
-                        data->zone_abs[ix] = dme1737_read(client,
+                        data->zone_abs[ix] = dme1737_read(data,
                                        DME1737_REG_ZONE_ABS(ix));
                }
                if (data->type != sch5027) {
                        for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
-                                data->zone_hyst[ix] = dme1737_read(client,
+                                data->zone_hyst[ix] = dme1737_read(data,
                                                DME1737_REG_ZONE_HYST(ix));
                        }
                }
                /* Alarm registers */
-                data->alarms = dme1737_read(client,
+                data->alarms = dme1737_read(data,
                                                DME1737_REG_ALARM1);
                /* Bit 7 tells us if the other alarm registers are non-zero and
                 * therefore also need to be read */
                if (data->alarms & 0x80) {
-                        data->alarms |= dme1737_read(client,
+                        data->alarms |= dme1737_read(data,
                                                DME1737_REG_ALARM2) << 8;
-                        data->alarms |= dme1737_read(client,
+                        data->alarms |= dme1737_read(data,
                                                DME1737_REG_ALARM3) << 16;
                }
                /* The ISA chips require explicit clearing of alarm bits.
                 * Don't worry, an alarm will come back if the condition
                 * that causes it still exists */
-                if (!client->driver) {
+                if (!data->client) {
                        if (data->alarms & 0xff0000) {
-                                dme1737_write(client, DME1737_REG_ALARM3,
+                                dme1737_write(data, DME1737_REG_ALARM3,
                                              0xff);
                        }
                        if (data->alarms & 0xff00) {
-                                dme1737_write(client, DME1737_REG_ALARM2,
+                                dme1737_write(data, DME1737_REG_ALARM2,
                                              0xff);
                        }
                        if (data->alarms & 0xff) {
-                                dme1737_write(client, DME1737_REG_ALARM1,
+                                dme1737_write(data, DME1737_REG_ALARM1,
                                              0xff);
                        }
                }
@@ -770,7 +771,6 @@ static ssize_t set_in(struct device *dev, struct device_attribute *attr,
                      const char *buf, size_t count)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
        struct sensor_device_attribute_2
                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
        int ix = sensor_attr_2->index;
@@ -781,12 +781,12 @@ static ssize_t set_in(struct device *dev, struct device_attribute *attr,
        switch (fn) {
        case SYS_IN_MIN:
                data->in_min[ix] = IN_TO_REG(val, data->in_nominal[ix]);
-                dme1737_write(client, DME1737_REG_IN_MIN(ix),
+                dme1737_write(data, DME1737_REG_IN_MIN(ix),
                              data->in_min[ix]);
                break;
        case SYS_IN_MAX:
                data->in_max[ix] = IN_TO_REG(val, data->in_nominal[ix]);
-                dme1737_write(client, DME1737_REG_IN_MAX(ix),
+                dme1737_write(data, DME1737_REG_IN_MAX(ix),
                              data->in_max[ix]);
                break;
        default:
@@ -850,7 +850,6 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
        struct sensor_device_attribute_2
                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
        int ix = sensor_attr_2->index;
@@ -861,17 +860,17 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
        switch (fn) {
        case SYS_TEMP_MIN:
                data->temp_min[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_TEMP_MIN(ix),
+                dme1737_write(data, DME1737_REG_TEMP_MIN(ix),
                              data->temp_min[ix]);
                break;
        case SYS_TEMP_MAX:
                data->temp_max[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_TEMP_MAX(ix),
+                dme1737_write(data, DME1737_REG_TEMP_MAX(ix),
                              data->temp_max[ix]);
                break;
        case SYS_TEMP_OFFSET:
                data->temp_offset[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_TEMP_OFFSET(ix),
+                dme1737_write(data, DME1737_REG_TEMP_OFFSET(ix),
                              data->temp_offset[ix]);
                break;
        default:
@@ -939,7 +938,6 @@ static ssize_t set_zone(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
        struct sensor_device_attribute_2
                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
        int ix = sensor_attr_2->index;
@@ -950,37 +948,37 @@ static ssize_t set_zone(struct device *dev, struct device_attribute *attr,
        switch (fn) {
        case SYS_ZONE_AUTO_POINT1_TEMP_HYST:
                /* Refresh the cache */
-                data->zone_low[ix] = dme1737_read(client,
+                data->zone_low[ix] = dme1737_read(data,
                                                  DME1737_REG_ZONE_LOW(ix));
                /* Modify the temp hyst value */
                data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG(
                                        TEMP_FROM_REG(data->zone_low[ix], 8) -
-                                        val, ix, dme1737_read(client,
+                                        val, ix, dme1737_read(data,
                                        DME1737_REG_ZONE_HYST(ix == 2)));
-                dme1737_write(client, DME1737_REG_ZONE_HYST(ix == 2),
+                dme1737_write(data, DME1737_REG_ZONE_HYST(ix == 2),
                              data->zone_hyst[ix == 2]);
                break;
        case SYS_ZONE_AUTO_POINT1_TEMP:
                data->zone_low[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_ZONE_LOW(ix),
+                dme1737_write(data, DME1737_REG_ZONE_LOW(ix),
                              data->zone_low[ix]);
                break;
        case SYS_ZONE_AUTO_POINT2_TEMP:
                /* Refresh the cache */
-                data->zone_low[ix] = dme1737_read(client,
+                data->zone_low[ix] = dme1737_read(data,
                                                  DME1737_REG_ZONE_LOW(ix));
                /* Modify the temp range value (which is stored in the upper
                 * nibble of the pwm_freq register) */
                data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val -
                                        TEMP_FROM_REG(data->zone_low[ix], 8),
-                                        dme1737_read(client,
+                                        dme1737_read(data,
                                        DME1737_REG_PWM_FREQ(ix)));
-                dme1737_write(client, DME1737_REG_PWM_FREQ(ix),
+                dme1737_write(data, DME1737_REG_PWM_FREQ(ix),
                              data->pwm_freq[ix]);
                break;
        case SYS_ZONE_AUTO_POINT3_TEMP:
                data->zone_abs[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_ZONE_ABS(ix),
+                dme1737_write(data, DME1737_REG_ZONE_ABS(ix),
                              data->zone_abs[ix]);
                break;
        default:
@@ -1046,7 +1044,6 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
                       const char *buf, size_t count)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
        struct sensor_device_attribute_2
                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
        int ix = sensor_attr_2->index;
@@ -1060,21 +1057,21 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
                        data->fan_min[ix] = FAN_TO_REG(val, 0);
                } else {
                        /* Refresh the cache */
-                        data->fan_opt[ix] = dme1737_read(client,
+                        data->fan_opt[ix] = dme1737_read(data,
                                                DME1737_REG_FAN_OPT(ix));
                        /* Modify the fan min value */
                        data->fan_min[ix] = FAN_TO_REG(val,
                                        FAN_TPC_FROM_REG(data->fan_opt[ix]));
                }
-                dme1737_write(client, DME1737_REG_FAN_MIN(ix),
+                dme1737_write(data, DME1737_REG_FAN_MIN(ix),
                              data->fan_min[ix] & 0xff);
-                dme1737_write(client, DME1737_REG_FAN_MIN(ix) + 1,
+                dme1737_write(data, DME1737_REG_FAN_MIN(ix) + 1,
                              data->fan_min[ix] >> 8);
                break;
        case SYS_FAN_MAX:
                /* Only valid for fan[5-6] */
                data->fan_max[ix - 4] = FAN_MAX_TO_REG(val);
-                dme1737_write(client, DME1737_REG_FAN_MAX(ix),
+                dme1737_write(data, DME1737_REG_FAN_MAX(ix),
                              data->fan_max[ix - 4]);
                break;
        case SYS_FAN_TYPE:
@@ -1086,9 +1083,9 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
                                 val);
                        goto exit;
                }
-                data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(client,
+                data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(data,
                                        DME1737_REG_FAN_OPT(ix)));
-                dme1737_write(client, DME1737_REG_FAN_OPT(ix),
+                dme1737_write(data, DME1737_REG_FAN_OPT(ix),
                              data->fan_opt[ix]);
                break;
        default:
@@ -1185,7 +1182,6 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                       const char *buf, size_t count)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
        struct sensor_device_attribute_2
                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
        int ix = sensor_attr_2->index;
@@ -1196,12 +1192,12 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
        switch (fn) {
        case SYS_PWM:
                data->pwm[ix] = SENSORS_LIMIT(val, 0, 255);
-                dme1737_write(client, DME1737_REG_PWM(ix), data->pwm[ix]);
+                dme1737_write(data, DME1737_REG_PWM(ix), data->pwm[ix]);
                break;
        case SYS_PWM_FREQ:
-                data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(client,
+                data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(data,
                                                DME1737_REG_PWM_FREQ(ix)));
-                dme1737_write(client, DME1737_REG_PWM_FREQ(ix),
+                dme1737_write(data, DME1737_REG_PWM_FREQ(ix),
                              data->pwm_freq[ix]);
                break;
        case SYS_PWM_ENABLE:
@@ -1214,7 +1210,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        goto exit;
                }
                /* Refresh the cache */
-                data->pwm_config[ix] = dme1737_read(client,
+                data->pwm_config[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_CONFIG(ix));
                if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) {
                        /* Bail out if no change */
@@ -1226,14 +1222,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        data->pwm_acz[ix] = PWM_ACZ_FROM_REG(
                                                        data->pwm_config[ix]);
                        /* Save the current ramp rate state and disable it */
-                        data->pwm_rr[ix > 0] = dme1737_read(client,
+                        data->pwm_rr[ix > 0] = dme1737_read(data,
                                                DME1737_REG_PWM_RR(ix > 0));
                        data->pwm_rr_en &= ~(1 << ix);
                        if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) {
                                data->pwm_rr_en |= (1 << ix);
                                data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix,
                                                        data->pwm_rr[ix > 0]);
-                                dme1737_write(client,
+                                dme1737_write(data,
                                              DME1737_REG_PWM_RR(ix > 0),
                                              data->pwm_rr[ix > 0]);
                        }
@@ -1247,14 +1243,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        /* Turn fan fully on */
                        data->pwm_config[ix] = PWM_EN_TO_REG(0,
                                                        data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                      data->pwm_config[ix]);
                        break;
                case 1:
                        /* Turn on manual mode */
                        data->pwm_config[ix] = PWM_EN_TO_REG(1,
                                                        data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                      data->pwm_config[ix]);
                        /* Change permissions of pwm[ix] to read-writeable */
                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
@@ -1269,14 +1265,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        data->pwm_config[ix] = PWM_ACZ_TO_REG(
                                                        data->pwm_acz[ix],
                                                        data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                      data->pwm_config[ix]);
                        /* Enable PWM ramp rate if previously enabled */
                        if (data->pwm_rr_en & (1 << ix)) {
                                data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix,
-                                                dme1737_read(client,
+                                                dme1737_read(data,
                                                DME1737_REG_PWM_RR(ix > 0)));
-                                dme1737_write(client,
+                                dme1737_write(data,
                                              DME1737_REG_PWM_RR(ix > 0),
                                              data->pwm_rr[ix > 0]);
                        }
@@ -1286,9 +1282,9 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
        case SYS_PWM_RAMP_RATE:
                /* Only valid for pwm[1-3] */
                /* Refresh the cache */
-                data->pwm_config[ix] = dme1737_read(client,
+                data->pwm_config[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_CONFIG(ix));
-                data->pwm_rr[ix > 0] = dme1737_read(client,
+                data->pwm_rr[ix > 0] = dme1737_read(data,
                                                DME1737_REG_PWM_RR(ix > 0));
                /* Set the ramp rate value */
                if (val > 0) {
@@ -1301,7 +1297,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix,
                                                        data->pwm_rr[ix > 0]);
                }
-                dme1737_write(client, DME1737_REG_PWM_RR(ix > 0),
+                dme1737_write(data, DME1737_REG_PWM_RR(ix > 0),
                              data->pwm_rr[ix > 0]);
                break;
        case SYS_PWM_AUTO_CHANNELS_ZONE:
@@ -1315,14 +1311,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        goto exit;
                }
                /* Refresh the cache */
-                data->pwm_config[ix] = dme1737_read(client,
+                data->pwm_config[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_CONFIG(ix));
                if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
                        /* PWM is already in auto mode so update the temp
                         * channel assignment */
                        data->pwm_config[ix] = PWM_ACZ_TO_REG(val,
                                                data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                      data->pwm_config[ix]);
                } else {
                        /* PWM is not in auto mode so we save the temp
@@ -1333,7 +1329,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
        case SYS_PWM_AUTO_PWM_MIN:
                /* Only valid for pwm[1-3] */
                /* Refresh the cache */
-                data->pwm_min[ix] = dme1737_read(client,
+                data->pwm_min[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_MIN(ix));
                /* There are only 2 values supported for the auto_pwm_min
                 * value: 0 or auto_point1_pwm. So if the temperature drops
@@ -1341,20 +1337,20 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                 * off or runs at auto_point1_pwm duty-cycle. */
                if (val > ((data->pwm_min[ix] + 1) / 2)) {
                        data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix,
-                                                dme1737_read(client,
+                                                dme1737_read(data,
                                                DME1737_REG_PWM_RR(0)));
                } else {
                        data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix,
-                                                dme1737_read(client,
+                                                dme1737_read(data,
                                                DME1737_REG_PWM_RR(0)));
                }
-                dme1737_write(client, DME1737_REG_PWM_RR(0),
+                dme1737_write(data, DME1737_REG_PWM_RR(0),
                              data->pwm_rr[0]);
                break;
        case SYS_PWM_AUTO_POINT1_PWM:
                /* Only valid for pwm[1-3] */
                data->pwm_min[ix] = SENSORS_LIMIT(val, 0, 255);
-                dme1737_write(client, DME1737_REG_PWM_MIN(ix),
+                dme1737_write(data, DME1737_REG_PWM_MIN(ix),
                              data->pwm_min[ix]);
                break;
        default:
@@ -1402,7 +1398,7 @@ static ssize_t show_name(struct device *dev, struct device_attribute *attr,
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        return sprintf(buf, "%s\n", data->client.name);
+        return sprintf(buf, "%s\n", data->name);
 }
 /* ---------------------------------------------------------------------
@@ -1908,7 +1904,7 @@ static void dme1737_remove_files(struct device *dev)
        sysfs_remove_group(&dev->kobj, &dme1737_group);
-        if (!data->client.driver) {
+        if (!data->client) {
                sysfs_remove_file(&dev->kobj, &dev_attr_name.attr);
        }
 }
@@ -1919,7 +1915,7 @@ static int dme1737_create_files(struct device *dev)
        int err, ix;
        /* Create a name attribute for ISA devices */
-        if (!data->client.driver &&
+        if (!data->client &&
            (err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr))) {
                goto exit;
        }
@@ -2013,14 +2009,14 @@ exit:
 static int dme1737_init_device(struct device *dev)
 {
        struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
+        struct i2c_client *client = data->client;
        int ix;
        u8 reg;
        /* Point to the right nominal voltages array */
        data->in_nominal = IN_NOMINAL(data->type);
-        data->config = dme1737_read(client, DME1737_REG_CONFIG);
+        data->config = dme1737_read(data, DME1737_REG_CONFIG);
        /* Inform if part is not monitoring/started */
        if (!(data->config & 0x01)) {
                if (!force_start) {
@@ -2032,7 +2028,7 @@ static int dme1737_init_device(struct device *dev)
                /* Force monitoring */
                data->config |= 0x01;
-                dme1737_write(client, DME1737_REG_CONFIG, data->config);
+                dme1737_write(data, DME1737_REG_CONFIG, data->config);
        }
        /* Inform if part is not ready */
        if (!(data->config & 0x04)) {
@@ -2041,8 +2037,8 @@ static int dme1737_init_device(struct device *dev)
        }
        /* Determine which optional fan and pwm features are enabled/present */
-        if (client->driver) {   /* I2C chip */
+        if (client) {   /* I2C chip */
-                data->config2 = dme1737_read(client, DME1737_REG_CONFIG2);
+                data->config2 = dme1737_read(data, DME1737_REG_CONFIG2);
                /* Check if optional fan3 input is enabled */
                if (data->config2 & 0x04) {
                        data->has_fan |= (1 << 2);
@@ -2051,7 +2047,7 @@ static int dme1737_init_device(struct device *dev)
                /* Fan4 and pwm3 are only available if the client's I2C address
                 * is the default 0x2e. Otherwise the I/Os associated with
                 * these functions are used for addr enable/select. */
-                if (data->client.addr == 0x2e) {
+                if (client->addr == 0x2e) {
                        data->has_fan |= (1 << 3);
                        data->has_pwm |= (1 << 2);
                }
@@ -2086,16 +2082,16 @@ static int dme1737_init_device(struct device *dev)
                 (data->has_fan & (1 << 4)) ? "yes" : "no",
                 (data->has_fan & (1 << 5)) ? "yes" : "no");
-        reg = dme1737_read(client, DME1737_REG_TACH_PWM);
+        reg = dme1737_read(data, DME1737_REG_TACH_PWM);
        /* Inform if fan-to-pwm mapping differs from the default */
-        if (client->driver && reg != 0xa4) {   /* I2C chip */
+        if (client && reg != 0xa4) {   /* I2C chip */
                dev_warn(dev, "Non-standard fan to pwm mapping: "
                         "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, "
                         "fan4->pwm%d. Please report to the driver "
                         "maintainer.\n",
                         (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1,
                         ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1);
-        } else if (!client->driver && reg != 0x24) {   /* ISA chip */
+        } else if (!client && reg != 0x24) {   /* ISA chip */
                dev_warn(dev, "Non-standard fan to pwm mapping: "
                         "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d. "
                         "Please report to the driver maintainer.\n",
@@ -2108,7 +2104,7 @@ static int dme1737_init_device(struct device *dev)
         * disabled). */
        if (!(data->config & 0x02)) {
                for (ix = 0; ix < 3; ix++) {
-                        data->pwm_config[ix] = dme1737_read(client,
+                        data->pwm_config[ix] = dme1737_read(data,
                                                DME1737_REG_PWM_CONFIG(ix));
                        if ((data->has_pwm & (1 << ix)) &&
                            (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) {
@@ -2116,8 +2112,8 @@ static int dme1737_init_device(struct device *dev)
                                         "manual mode.\n", ix + 1);
                                data->pwm_config[ix] = PWM_EN_TO_REG(1,
                                                        data->pwm_config[ix]);
-                                dme1737_write(client, DME1737_REG_PWM(ix), 0);
+                                dme1737_write(data, DME1737_REG_PWM(ix), 0);
-                                dme1737_write(client,
+                                dme1737_write(data,
                                              DME1737_REG_PWM_CONFIG(ix),
                                              data->pwm_config[ix]);
                        }
@@ -2191,37 +2187,24 @@ exit:
        return err;
 }
-static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
+/* Return 0 if detection is successful, -ENODEV otherwise */
-                              int kind)
+static int dme1737_i2c_detect(struct i2c_client *client, int kind,
+                              struct i2c_board_info *info)
 {
+        struct i2c_adapter *adapter = client->adapter;
+        struct device *dev = &adapter->dev;
        u8 company, verstep = 0;
-        struct i2c_client *client;
-        struct dme1737_data *data;
-        struct device *dev;
-        int err = 0;
        const char *name;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-                goto exit;
+                return -ENODEV;
-        }
-        if (!(data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto exit;
        }
-        client = &data->client;
-        i2c_set_clientdata(client, data);
-        client->addr = address;
-        client->adapter = adapter;
-        client->driver = &dme1737_i2c_driver;
-        dev = &client->dev;
        /* A negative kind means that the driver was loaded with no force
         * parameter (default), so we must identify the chip. */
        if (kind < 0) {
-                company = dme1737_read(client, DME1737_REG_COMPANY);
+                company = i2c_smbus_read_byte_data(client, DME1737_REG_COMPANY);
-                verstep = dme1737_read(client, DME1737_REG_VERSTEP);
+                verstep = i2c_smbus_read_byte_data(client, DME1737_REG_VERSTEP);
                if (company == DME1737_COMPANY_SMSC &&
                    (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) {
@@ -2230,8 +2213,7 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
                           verstep == SCH5027_VERSTEP) {
                        kind = sch5027;
                } else {
-                        err = -ENODEV;
+                        return -ENODEV;
-                        goto exit_kfree;
                }
        }
@@ -2241,32 +2223,44 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
                kind = dme1737;
                name = "dme1737";
        }
-        data->type = kind;
-        /* Fill in the remaining client fields and put it into the global
-         * list */
-        strlcpy(client->name, name, I2C_NAME_SIZE);
-        mutex_init(&data->update_lock);
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(client))) {
-                goto exit_kfree;
-        }
        dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n",
                 kind == sch5027 ? "SCH5027" : "DME1737", client->addr,
                 verstep);
+        strlcpy(info->type, name, I2C_NAME_SIZE);
+        return 0;
+}
+static int dme1737_i2c_probe(struct i2c_client *client,
+                             const struct i2c_device_id *id)
+{
+        struct dme1737_data *data;
+        struct device *dev = &client->dev;
+        int err;
+        data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto exit;
+        }
+        i2c_set_clientdata(client, data);
+        data->type = id->driver_data;
+        data->client = client;
+        data->name = client->name;
+        mutex_init(&data->update_lock);
        /* Initialize the DME1737 chip */
        if ((err = dme1737_init_device(dev))) {
                dev_err(dev, "Failed to initialize device.\n");
-                goto exit_detach;
+                goto exit_kfree;
        }
        /* Create sysfs files */
        if ((err = dme1737_create_files(dev))) {
                dev_err(dev, "Failed to create sysfs files.\n");
-                goto exit_detach;
+                goto exit_kfree;
        }
        /* Register device */
@@ -2281,45 +2275,40 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
 exit_remove:
        dme1737_remove_files(dev);
-exit_detach:
-        i2c_detach_client(client);
 exit_kfree:
        kfree(data);
 exit:
        return err;
 }
-static int dme1737_i2c_attach_adapter(struct i2c_adapter *adapter)
+static int dme1737_i2c_remove(struct i2c_client *client)
-{
-        if (!(adapter->class & I2C_CLASS_HWMON)) {
-                return 0;
-        }
-        return i2c_probe(adapter, &addr_data, dme1737_i2c_detect);
-}
-static int dme1737_i2c_detach_client(struct i2c_client *client)
 {
        struct dme1737_data *data = i2c_get_clientdata(client);
-        int err;
        hwmon_device_unregister(data->hwmon_dev);
        dme1737_remove_files(&client->dev);
-        if ((err = i2c_detach_client(client))) {
-                return err;
-        }
        kfree(data);
        return 0;
 }
+static const struct i2c_device_id dme1737_id[] = {
+        { "dme1737", dme1737 },
+        { "sch5027", sch5027 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, dme1737_id);
 static struct i2c_driver dme1737_i2c_driver = {
+        .class = I2C_CLASS_HWMON,
        .driver = {
                .name = "dme1737",
        },
-        .attach_adapter = dme1737_i2c_attach_adapter,
+        .probe = dme1737_i2c_probe,
-        .detach_client = dme1737_i2c_detach_client,
+        .remove = dme1737_i2c_remove,
+        .id_table = dme1737_id,
+        .detect = dme1737_i2c_detect,
+        .address_data = &addr_data,
 };
 /* ---------------------------------------------------------------------
@@ -2403,7 +2392,6 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
 {
        u8 company, device;
        struct resource *res;
-        struct i2c_client *client;
        struct dme1737_data *data;
        struct device *dev = &pdev->dev;
        int err;
@@ -2422,15 +2410,13 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
                goto exit_release_region;
        }
-        client = &data->client;
+        data->addr = res->start;
-        i2c_set_clientdata(client, data);
-        client->addr = res->start;
        platform_set_drvdata(pdev, data);
        /* Skip chip detection if module is loaded with force_id parameter */
        if (!force_id) {
-                company = dme1737_read(client, DME1737_REG_COMPANY);
+                company = dme1737_read(data, DME1737_REG_COMPANY);
-                device = dme1737_read(client, DME1737_REG_DEVICE);
+                device = dme1737_read(data, DME1737_REG_DEVICE);
                if (!((company == DME1737_COMPANY_SMSC) &&
                      (device == SCH311X_DEVICE))) {
@@ -2441,10 +2427,10 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
        data->type = sch311x;
        /* Fill in the remaining client fields and initialize the mutex */
-        strlcpy(client->name, "sch311x", I2C_NAME_SIZE);
+        data->name = "sch311x";
        mutex_init(&data->update_lock);
-        dev_info(dev, "Found a SCH311x chip at 0x%04x\n", client->addr);
+        dev_info(dev, "Found a SCH311x chip at 0x%04x\n", data->addr);
        /* Initialize the chip */
        if ((err = dme1737_init_device(dev))) {
@@ -2485,7 +2471,7 @@ static int __devexit dme1737_isa_remove(struct platform_device *pdev)
        hwmon_device_unregister(data->hwmon_dev);
        dme1737_remove_files(&pdev->dev);
-        release_region(data->client.addr, DME1737_EXTENT);
+        release_region(data->addr, DME1737_EXTENT);
        platform_set_drvdata(pdev, NULL);
        kfree(data);
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 6ee997b2817c..acadbc51fc0f 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -55,7 +55,7 @@ config I2C_AMD756
 config I2C_AMD756_S4882
        tristate "SMBus multiplexing on the Tyan S4882"
-        depends on I2C_AMD756 && EXPERIMENTAL
+        depends on I2C_AMD756 && X86 && EXPERIMENTAL
        help
          Enabling this option will add specific SMBus support for the Tyan
          S4882 motherboard.  On this 4-CPU board, the SMBus is multiplexed
@@ -148,7 +148,7 @@ config I2C_NFORCE2
 config I2C_NFORCE2_S4985
        tristate "SMBus multiplexing on the Tyan S4985"
-        depends on I2C_NFORCE2 && EXPERIMENTAL
+        depends on I2C_NFORCE2 && X86 && EXPERIMENTAL
        help
          Enabling this option will add specific SMBus support for the Tyan
          S4985 motherboard.  On this 4-CPU board, the SMBus is multiplexed
@@ -209,7 +209,7 @@ config I2C_VIA
          will be called i2c-via.
 config I2C_VIAPRO
-        tristate "VIA VT82C596/82C686/82xx and CX700"
+        tristate "VIA VT82C596/82C686/82xx and CX700/VX800/VX820"
        depends on PCI
        help
          If you say yes to this option, support will be included for the VIA
@@ -223,6 +223,8 @@ config I2C_VIAPRO
            VT8237R/A/S
            VT8251
            CX700
+            VX800
+            VX820
          This driver can also be built as a module.  If so, the module
          will be called i2c-viapro.
@@ -330,6 +332,18 @@ config I2C_GPIO
          This is a very simple bitbanging I2C driver utilizing the
          arch-neutral GPIO API to control the SCL and SDA lines.
+config I2C_HIGHLANDER
+        tristate "Highlander FPGA SMBus interface"
+        depends on SH_HIGHLANDER
+        help
+          If you say yes to this option, support will be included for
+          the SMBus interface located in the FPGA on various Highlander
+          boards, particularly the R0P7780LC0011RL and R0P7785LC0011RL
+          FPGAs. This is wholly unrelated to the SoC I2C.
+          This driver can also be built as a module.  If so, the module
+          will be called i2c-highlander.
 config I2C_IBM_IIC
        tristate "IBM PPC 4xx on-chip I2C interface"
        depends on 4xx
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 97dbfa2107fe..0c2c4b26cdf1 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -31,6 +31,7 @@ obj-$(CONFIG_I2C_BLACKFIN_TWI)	+= i2c-bfin-twi.o
 obj-$(CONFIG_I2C_CPM)           += i2c-cpm.o
 obj-$(CONFIG_I2C_DAVINCI)       += i2c-davinci.o
 obj-$(CONFIG_I2C_GPIO)          += i2c-gpio.o
+obj-$(CONFIG_I2C_HIGHLANDER)    += i2c-highlander.o
 obj-$(CONFIG_I2C_IBM_IIC)       += i2c-ibm_iic.o
 obj-$(CONFIG_I2C_IOP3XX)        += i2c-iop3xx.o
 obj-$(CONFIG_I2C_IXP2000)       += i2c-ixp2000.o
diff --git a/drivers/i2c/busses/i2c-highlander.c b/drivers/i2c/busses/i2c-highlander.c
new file mode 100644
index 000000000000..f4d22ae9d294
--- /dev/null
+++ b/drivers/i2c/busses/i2c-highlander.c
@@ -0,0 +1,498 @@
+/*
+ * Renesas Solutions Highlander FPGA I2C/SMBus support.
+ *
+ * Supported devices: R0P7780LC0011RL, R0P7785LC0011RL
+ *
+ * Copyright (C) 2008  Paul Mundt
+ * Copyright (C) 2008  Renesas Solutions Corp.
+ * Copyright (C) 2008  Atom Create Engineering Co., Ltd.
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License version 2. See the file "COPYING" in the main directory
+ * of this archive for more details.
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/completion.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#define SMCR            0x00
+#define SMCR_START      (1 << 0)
+#define SMCR_IRIC       (1 << 1)
+#define SMCR_BBSY       (1 << 2)
+#define SMCR_ACKE       (1 << 3)
+#define SMCR_RST        (1 << 4)
+#define SMCR_IEIC       (1 << 6)
+#define SMSMADR         0x02
+#define SMMR            0x04
+#define SMMR_MODE0      (1 << 0)
+#define SMMR_MODE1      (1 << 1)
+#define SMMR_CAP        (1 << 3)
+#define SMMR_TMMD       (1 << 4)
+#define SMMR_SP         (1 << 7)
+#define SMSADR          0x06
+#define SMTRDR          0x46
+struct highlander_i2c_dev {
+        struct device           *dev;
+        void __iomem            *base;
+        struct i2c_adapter      adapter;
+        struct completion       cmd_complete;
+        unsigned long           last_read_time;
+        int                     irq;
+        u8                      *buf;
+        size_t                  buf_len;
+};
+static int iic_force_poll, iic_force_normal;
+static int iic_timeout = 1000, iic_read_delay;
+static inline void highlander_i2c_irq_enable(struct highlander_i2c_dev *dev)
+{
+        iowrite16(ioread16(dev->base + SMCR) | SMCR_IEIC, dev->base + SMCR);
+}
+static inline void highlander_i2c_irq_disable(struct highlander_i2c_dev *dev)
+{
+        iowrite16(ioread16(dev->base + SMCR) & ~SMCR_IEIC, dev->base + SMCR);
+}
+static inline void highlander_i2c_start(struct highlander_i2c_dev *dev)
+{
+        iowrite16(ioread16(dev->base + SMCR) | SMCR_START, dev->base + SMCR);
+}
+static inline void highlander_i2c_done(struct highlander_i2c_dev *dev)
+{
+        iowrite16(ioread16(dev->base + SMCR) | SMCR_IRIC, dev->base + SMCR);
+}
+static void highlander_i2c_setup(struct highlander_i2c_dev *dev)
+{
+        u16 smmr;
+        smmr = ioread16(dev->base + SMMR);
+        smmr |= SMMR_TMMD;
+        if (iic_force_normal)
+                smmr &= ~SMMR_SP;
+        else
+                smmr |= SMMR_SP;
+        iowrite16(smmr, dev->base + SMMR);
+}
+static void smbus_write_data(u8 *src, u16 *dst, int len)
+{
+        for (; len > 1; len -= 2) {
+                *dst++ = be16_to_cpup((u16 *)src);
+                src += 2;
+        }
+        if (len)
+                *dst = *src << 8;
+}
+static void smbus_read_data(u16 *src, u8 *dst, int len)
+{
+        for (; len > 1; len -= 2) {
+                *(u16 *)dst = cpu_to_be16p(src++);
+                dst += 2;
+        }
+        if (len)
+                *dst = *src >> 8;
+}
+static void highlander_i2c_command(struct highlander_i2c_dev *dev,
+                                   u8 command, int len)
+{
+        unsigned int i;
+        u16 cmd = (command << 8) | command;
+        for (i = 0; i < len; i += 2) {
+                if (len - i == 1)
+                        cmd = command << 8;
+                iowrite16(cmd, dev->base + SMSADR + i);
+                dev_dbg(dev->dev, "command data[%x] 0x%04x\n", i/2, cmd);
+        }
+}
+static int highlander_i2c_wait_for_bbsy(struct highlander_i2c_dev *dev)
+{
+        unsigned long timeout;
+        timeout = jiffies + msecs_to_jiffies(iic_timeout);
+        while (ioread16(dev->base + SMCR) & SMCR_BBSY) {
+                if (time_after(jiffies, timeout)) {
+                        dev_warn(dev->dev, "timeout waiting for bus ready\n");
+                        return -ETIMEDOUT;
+                }
+                msleep(1);
+        }
+        return 0;
+}
+static int highlander_i2c_reset(struct highlander_i2c_dev *dev)
+{
+        iowrite16(ioread16(dev->base + SMCR) | SMCR_RST, dev->base + SMCR);
+        return highlander_i2c_wait_for_bbsy(dev);
+}
+static int highlander_i2c_wait_for_ack(struct highlander_i2c_dev *dev)
+{
+        u16 tmp = ioread16(dev->base + SMCR);
+        if ((tmp & (SMCR_IRIC | SMCR_ACKE)) == SMCR_ACKE) {
+                dev_warn(dev->dev, "ack abnormality\n");
+                return highlander_i2c_reset(dev);
+        }
+        return 0;
+}
+static irqreturn_t highlander_i2c_irq(int irq, void *dev_id)
+{
+        struct highlander_i2c_dev *dev = dev_id;
+        highlander_i2c_done(dev);
+        complete(&dev->cmd_complete);
+        return IRQ_HANDLED;
+}
+static void highlander_i2c_poll(struct highlander_i2c_dev *dev)
+{
+        unsigned long timeout;
+        u16 smcr;
+        timeout = jiffies + msecs_to_jiffies(iic_timeout);
+        for (;;) {
+                smcr = ioread16(dev->base + SMCR);
+                /*
+                 * Don't bother checking ACKE here, this and the reset
+                 * are handled in highlander_i2c_wait_xfer_done() when
+                 * waiting for the ACK.
+                 */
+                if (smcr & SMCR_IRIC)
+                        return;
+                if (time_after(jiffies, timeout))
+                        break;
+                cpu_relax();
+                cond_resched();
+        }
+        dev_err(dev->dev, "polling timed out\n");
+}
+static inline int highlander_i2c_wait_xfer_done(struct highlander_i2c_dev *dev)
+{
+        if (dev->irq)
+                wait_for_completion_timeout(&dev->cmd_complete,
+                                          msecs_to_jiffies(iic_timeout));
+        else
+                /* busy looping, the IRQ of champions */
+                highlander_i2c_poll(dev);
+        return highlander_i2c_wait_for_ack(dev);
+}
+static int highlander_i2c_read(struct highlander_i2c_dev *dev)
+{
+        int i, cnt;
+        u16 data[16];
+        if (highlander_i2c_wait_for_bbsy(dev))
+                return -EAGAIN;
+        highlander_i2c_start(dev);
+        if (highlander_i2c_wait_xfer_done(dev)) {
+                dev_err(dev->dev, "Arbitration loss\n");
+                return -EAGAIN;
+        }
+        /*
+         * The R0P7780LC0011RL FPGA needs a significant delay between
+         * data read cycles, otherwise the transciever gets confused and
+         * garbage is returned when the read is subsequently aborted.
+         *
+         * It is not sufficient to wait for BBSY.
+         *
+         * While this generally only applies to the older SH7780-based
+         * Highlanders, the same issue can be observed on SH7785 ones,
+         * albeit less frequently. SH7780-based Highlanders may need
+         * this to be as high as 1000 ms.
+         */
+        if (iic_read_delay && time_before(jiffies, dev->last_read_time +
+                                 msecs_to_jiffies(iic_read_delay)))
+                msleep(jiffies_to_msecs((dev->last_read_time +
+                                msecs_to_jiffies(iic_read_delay)) - jiffies));
+        cnt = (dev->buf_len + 1) >> 1;
+        for (i = 0; i < cnt; i++) {
+                data[i] = ioread16(dev->base + SMTRDR + (i * sizeof(u16)));
+                dev_dbg(dev->dev, "read data[%x] 0x%04x\n", i, data[i]);
+        }
+        smbus_read_data(data, dev->buf, dev->buf_len);
+        dev->last_read_time = jiffies;
+        return 0;
+}
+static int highlander_i2c_write(struct highlander_i2c_dev *dev)
+{
+        int i, cnt;
+        u16 data[16];
+        smbus_write_data(dev->buf, data, dev->buf_len);
+        cnt = (dev->buf_len + 1) >> 1;
+        for (i = 0; i < cnt; i++) {
+                iowrite16(data[i], dev->base + SMTRDR + (i * sizeof(u16)));
+                dev_dbg(dev->dev, "write data[%x] 0x%04x\n", i, data[i]);
+        }
+        if (highlander_i2c_wait_for_bbsy(dev))
+                return -EAGAIN;
+        highlander_i2c_start(dev);
+        return highlander_i2c_wait_xfer_done(dev);
+}
+static int highlander_i2c_smbus_xfer(struct i2c_adapter *adap, u16 addr,
+                                  unsigned short flags, char read_write,
+                                  u8 command, int size,
+                                  union i2c_smbus_data *data)
+{
+        struct highlander_i2c_dev *dev = i2c_get_adapdata(adap);
+        int read = read_write & I2C_SMBUS_READ;
+        u16 tmp;
+        init_completion(&dev->cmd_complete);
+        dev_dbg(dev->dev, "addr %04x, command %02x, read_write %d, size %d\n",
+                addr, command, read_write, size);
+        /*
+         * Set up the buffer and transfer size
+         */
+        switch (size) {
+        case I2C_SMBUS_BYTE_DATA:
+                dev->buf = &data->byte;
+                dev->buf_len = 1;
+                break;
+        case I2C_SMBUS_I2C_BLOCK_DATA:
+                dev->buf = &data->block[1];
+                dev->buf_len = data->block[0];
+                break;
+        default:
+                dev_err(dev->dev, "unsupported command %d\n", size);
+                return -EINVAL;
+        }
+        /*
+         * Encode the mode setting
+         */
+        tmp = ioread16(dev->base + SMMR);
+        tmp &= ~(SMMR_MODE0 | SMMR_MODE1);
+        switch (dev->buf_len) {
+        case 1:
+                /* default */
+                break;
+        case 8:
+                tmp |= SMMR_MODE0;
+                break;
+        case 16:
+                tmp |= SMMR_MODE1;
+                break;
+        case 32:
+                tmp |= (SMMR_MODE0 | SMMR_MODE1);
+                break;
+        default:
+                dev_err(dev->dev, "unsupported xfer size %d\n", dev->buf_len);
+                return -EINVAL;
+        }
+        iowrite16(tmp, dev->base + SMMR);
+        /* Ensure we're in a sane state */
+        highlander_i2c_done(dev);
+        /* Set slave address */
+        iowrite16((addr << 1) | read, dev->base + SMSMADR);
+        highlander_i2c_command(dev, command, dev->buf_len);
+        if (read)
+                return highlander_i2c_read(dev);
+        else
+                return highlander_i2c_write(dev);
+}
+static u32 highlander_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK;
+}
+static const struct i2c_algorithm highlander_i2c_algo = {
+        .smbus_xfer     = highlander_i2c_smbus_xfer,
+        .functionality  = highlander_i2c_func,
+};
+static int __devinit highlander_i2c_probe(struct platform_device *pdev)
+{
+        struct highlander_i2c_dev *dev;
+        struct i2c_adapter *adap;
+        struct resource *res;
+        int ret;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (unlikely(!res)) {
+                dev_err(&pdev->dev, "no mem resource\n");
+                return -ENODEV;
+        }
+        dev = kzalloc(sizeof(struct highlander_i2c_dev), GFP_KERNEL);
+        if (unlikely(!dev))
+                return -ENOMEM;
+        dev->base = ioremap_nocache(res->start, res->end - res->start + 1);
+        if (unlikely(!dev->base)) {
+                ret = -ENXIO;
+                goto err;
+        }
+        dev->dev = &pdev->dev;
+        platform_set_drvdata(pdev, dev);
+        dev->irq = platform_get_irq(pdev, 0);
+        if (iic_force_poll)
+                dev->irq = 0;
+        if (dev->irq) {
+                ret = request_irq(dev->irq, highlander_i2c_irq, IRQF_DISABLED,
+                                  pdev->name, dev);
+                if (unlikely(ret))
+                        goto err_unmap;
+                highlander_i2c_irq_enable(dev);
+        } else {
+                dev_notice(&pdev->dev, "no IRQ, using polling mode\n");
+                highlander_i2c_irq_disable(dev);
+        }
+        dev->last_read_time = jiffies;  /* initial read jiffies */
+        highlander_i2c_setup(dev);
+        adap = &dev->adapter;
+        i2c_set_adapdata(adap, dev);
+        adap->owner = THIS_MODULE;
+        adap->class = I2C_CLASS_HWMON;
+        strlcpy(adap->name, "HL FPGA I2C adapter", sizeof(adap->name));
+        adap->algo = &highlander_i2c_algo;
+        adap->dev.parent = &pdev->dev;
+        adap->nr = pdev->id;
+        /*
+         * Reset the adapter
+         */
+        ret = highlander_i2c_reset(dev);
+        if (unlikely(ret)) {
+                dev_err(&pdev->dev, "controller didn't come up\n");
+                goto err_free_irq;
+        }
+        ret = i2c_add_numbered_adapter(adap);
+        if (unlikely(ret)) {
+                dev_err(&pdev->dev, "failure adding adapter\n");
+                goto err_free_irq;
+        }
+        return 0;
+err_free_irq:
+        if (dev->irq)
+                free_irq(dev->irq, dev);
+err_unmap:
+        iounmap(dev->base);
+err:
+        kfree(dev);
+        platform_set_drvdata(pdev, NULL);
+        return ret;
+}
+static int __devexit highlander_i2c_remove(struct platform_device *pdev)
+{
+        struct highlander_i2c_dev *dev = platform_get_drvdata(pdev);
+        i2c_del_adapter(&dev->adapter);
+        if (dev->irq)
+                free_irq(dev->irq, dev);
+        iounmap(dev->base);
+        kfree(dev);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+static struct platform_driver highlander_i2c_driver = {
+        .driver         = {
+                .name   = "i2c-highlander",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = highlander_i2c_probe,
+        .remove         = __devexit_p(highlander_i2c_remove),
+};
+static int __init highlander_i2c_init(void)
+{
+        return platform_driver_register(&highlander_i2c_driver);
+}
+static void __exit highlander_i2c_exit(void)
+{
+        platform_driver_unregister(&highlander_i2c_driver);
+}
+module_init(highlander_i2c_init);
+module_exit(highlander_i2c_exit);
+MODULE_AUTHOR("Paul Mundt");
+MODULE_DESCRIPTION("Renesas Highlander FPGA I2C/SMBus adapter");
+MODULE_LICENSE("GPL v2");
+module_param(iic_force_poll, bool, 0);
+module_param(iic_force_normal, bool, 0);
+module_param(iic_timeout, int, 0);
+module_param(iic_read_delay, int, 0);
+MODULE_PARM_DESC(iic_force_poll, "Force polling mode");
+MODULE_PARM_DESC(iic_force_normal,
+                 "Force normal mode (100 kHz), default is fast mode (400 kHz)");
+MODULE_PARM_DESC(iic_timeout, "Set timeout value in msecs (default 1000 ms)");
+MODULE_PARM_DESC(iic_read_delay,
+                 "Delay between data read cycles (default 0 ms)");
diff --git a/drivers/i2c/busses/i2c-parport-light.c b/drivers/i2c/busses/i2c-parport-light.c
index c6faf9bdad18..b2b8380f6602 100644
--- a/drivers/i2c/busses/i2c-parport-light.c
+++ b/drivers/i2c/busses/i2c-parport-light.c
@@ -123,11 +123,6 @@ static struct i2c_adapter parport_adapter = {
 static int __devinit i2c_parport_probe(struct platform_device *pdev)
 {
        int err;
-        struct resource *res;
-        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        if (!request_region(res->start, res->end - res->start + 1, DRVNAME))
-                return -EBUSY;
        /* Reset hardware to a sane state (SCL and SDA high) */
        parport_setsda(NULL, 1);
@@ -138,29 +133,19 @@ static int __devinit i2c_parport_probe(struct platform_device *pdev)
        parport_adapter.dev.parent = &pdev->dev;
        err = i2c_bit_add_bus(&parport_adapter);
-        if (err) {
+        if (err)
                dev_err(&pdev->dev, "Unable to register with I2C\n");
-                goto exit_region;
-        }
-        return 0;
-exit_region:
-        release_region(res->start, res->end - res->start + 1);
        return err;
 }
 static int __devexit i2c_parport_remove(struct platform_device *pdev)
 {
-        struct resource *res;
        i2c_del_adapter(&parport_adapter);
        /* Un-init if needed (power off...) */
        if (adapter_parm[type].init.val)
                line_set(0, &adapter_parm[type].init);
-        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        release_region(res->start, res->end - res->start + 1);
        return 0;
 }
@@ -175,12 +160,6 @@ static struct platform_driver i2c_parport_driver = {
 static int __init i2c_parport_device_add(u16 address)
 {
-        struct resource res = {
-                .start  = address,
-                .end    = address + 2,
-                .name   = DRVNAME,
-                .flags  = IORESOURCE_IO,
-        };
        int err;
        pdev = platform_device_alloc(DRVNAME, -1);
@@ -190,13 +169,6 @@ static int __init i2c_parport_device_add(u16 address)
                goto exit;
        }
-        err = platform_device_add_resources(pdev, &res, 1);
-        if (err) {
-                printk(KERN_ERR DRVNAME ": Device resource addition failed "
-                       "(%d)\n", err);
-                goto exit_device_put;
-        }
        err = platform_device_add(pdev);
        if (err) {
                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
@@ -231,13 +203,16 @@ static int __init i2c_parport_init(void)
                base = DEFAULT_BASE;
        }
+        if (!request_region(base, 3, DRVNAME))
+                return -EBUSY;
        if (!adapter_parm[type].getscl.val)
                parport_algo_data.getscl = NULL;
        /* Sets global pdev as a side effect */
        err = i2c_parport_device_add(base);
        if (err)
-                goto exit;
+                goto exit_release;
        err = platform_driver_register(&i2c_parport_driver);
        if (err)
@@ -247,7 +222,8 @@ static int __init i2c_parport_init(void)
 exit_device:
        platform_device_unregister(pdev);
-exit:
+exit_release:
+        release_region(base, 3);
        return err;
 }
@@ -255,6 +231,7 @@ static void __exit i2c_parport_exit(void)
 {
        platform_driver_unregister(&i2c_parport_driver);
        platform_device_unregister(pdev);
+        release_region(base, 3);
 }
 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
diff --git a/drivers/i2c/busses/i2c-pca-isa.c b/drivers/i2c/busses/i2c-pca-isa.c
index 28d8463b74ad..9eb76268ec78 100644
--- a/drivers/i2c/busses/i2c-pca-isa.c
+++ b/drivers/i2c/busses/i2c-pca-isa.c
@@ -36,8 +36,8 @@
 #define DRIVER "i2c-pca-isa"
 #define IO_SIZE 4
-static unsigned long base   = 0x330;
+static unsigned long base;
-static int irq    = 10;
+static int irq = -1;
 /* Data sheet recommends 59kHz for 100kHz operation due to variation
 * in the actual clock rate */
@@ -107,6 +107,19 @@ static struct i2c_adapter pca_isa_ops = {
        .timeout        = 100,
 };
+static int __devinit pca_isa_match(struct device *dev, unsigned int id)
+{
+        int match = base != 0;
+        if (match) {
+                if (irq <= -1)
+                        dev_warn(dev, "Using polling mode (specify irq)\n");
+        } else
+                dev_err(dev, "Please specify I/O base\n");
+        return match;
+}
 static int __devinit pca_isa_probe(struct device *dev, unsigned int id)
 {
        init_waitqueue_head(&pca_wait);
@@ -153,7 +166,7 @@ static int __devexit pca_isa_remove(struct device *dev, unsigned int id)
 {
        i2c_del_adapter(&pca_isa_ops);
-        if (irq > 0) {
+        if (irq > -1) {
                disable_irq(irq);
                free_irq(irq, &pca_isa_ops);
        }
@@ -163,6 +176,7 @@ static int __devexit pca_isa_remove(struct device *dev, unsigned int id)
 }
 static struct isa_driver pca_isa_driver = {
+        .match          = pca_isa_match,
        .probe          = pca_isa_probe,
        .remove         = __devexit_p(pca_isa_remove),
        .driver = {
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c
index 862eb352a2d9..73dc52e114eb 100644
--- a/drivers/i2c/busses/i2c-viapro.c
+++ b/drivers/i2c/busses/i2c-viapro.c
@@ -36,6 +36,7 @@
   VT8237S            0x3372             yes
   VT8251             0x3287             yes
   CX700              0x8324             yes
+   VX800/VX820        0x8353             yes
   Note: we assume there can only be one device, with one SMBus interface.
 */
@@ -82,6 +83,7 @@ static unsigned short SMBHSTCFG = 0xD2;
 #define VT596_BYTE              0x04
 #define VT596_BYTE_DATA         0x08
 #define VT596_WORD_DATA         0x0C
+#define VT596_PROC_CALL         0x10
 #define VT596_BLOCK_DATA        0x14
 #define VT596_I2C_BLOCK_DATA    0x34
@@ -232,6 +234,12 @@ static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
                }
                size = VT596_WORD_DATA;
                break;
+        case I2C_SMBUS_PROC_CALL:
+                outb_p(command, SMBHSTCMD);
+                outb_p(data->word & 0xff, SMBHSTDAT0);
+                outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
+                size = VT596_PROC_CALL;
+                break;
        case I2C_SMBUS_I2C_BLOCK_DATA:
                if (!(vt596_features & FEATURE_I2CBLOCK))
                        goto exit_unsupported;
@@ -262,6 +270,9 @@ static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
        if (status)
                return status;
+        if (size == VT596_PROC_CALL)
+                read_write = I2C_SMBUS_READ;
        if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
                return 0;
@@ -271,6 +282,7 @@ static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
                data->byte = inb_p(SMBHSTDAT0);
                break;
        case VT596_WORD_DATA:
+        case VT596_PROC_CALL:
                data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
                break;
        case VT596_I2C_BLOCK_DATA:
@@ -295,7 +307,7 @@ static u32 vt596_func(struct i2c_adapter *adapter)
 {
        u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
            I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
-            I2C_FUNC_SMBUS_BLOCK_DATA;
+            I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
        if (vt596_features & FEATURE_I2CBLOCK)
                func |= I2C_FUNC_SMBUS_I2C_BLOCK;
@@ -396,6 +408,7 @@ found:
        switch (pdev->device) {
        case PCI_DEVICE_ID_VIA_CX700:
+        case PCI_DEVICE_ID_VIA_VX800:
        case PCI_DEVICE_ID_VIA_8251:
        case PCI_DEVICE_ID_VIA_8237:
        case PCI_DEVICE_ID_VIA_8237A:
@@ -459,6 +472,8 @@ static struct pci_device_id vt596_ids[] = {
          .driver_data = SMBBA3 },
        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
          .driver_data = SMBBA3 },
+        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
+          .driver_data = SMBBA3 },
        { 0, }
 };
diff --git a/drivers/i2c/chips/isp1301_omap.c b/drivers/i2c/chips/isp1301_omap.c
index 4655b794ebe3..28902ebd5539 100644
--- a/drivers/i2c/chips/isp1301_omap.c
+++ b/drivers/i2c/chips/isp1301_omap.c
@@ -49,10 +49,9 @@ MODULE_LICENSE("GPL");
 struct isp1301 {
        struct otg_transceiver  otg;
-        struct i2c_client       client;
+        struct i2c_client       *client;
        void                    (*i2c_release)(struct device *dev);
-        int                     irq;
        int                     irq_type;
        u32                     last_otg_ctrl;
@@ -138,14 +137,6 @@ static inline void notresponding(struct isp1301 *isp)
 /*-------------------------------------------------------------------------*/
-/* only two addresses possible */
-#define ISP_BASE                0x2c
-static unsigned short normal_i2c[] = {
-        ISP_BASE, ISP_BASE + 1,
-        I2C_CLIENT_END };
-I2C_CLIENT_INSMOD;
 static struct i2c_driver isp1301_driver;
 /* smbus apis are used for portability */
@@ -153,25 +144,25 @@ static struct i2c_driver isp1301_driver;
 static inline u8
 isp1301_get_u8(struct isp1301 *isp, u8 reg)
 {
-        return i2c_smbus_read_byte_data(&isp->client, reg + 0);
+        return i2c_smbus_read_byte_data(isp->client, reg + 0);
 }
 static inline int
 isp1301_get_u16(struct isp1301 *isp, u8 reg)
 {
-        return i2c_smbus_read_word_data(&isp->client, reg);
+        return i2c_smbus_read_word_data(isp->client, reg);
 }
 static inline int
 isp1301_set_bits(struct isp1301 *isp, u8 reg, u8 bits)
 {
-        return i2c_smbus_write_byte_data(&isp->client, reg + 0, bits);
+        return i2c_smbus_write_byte_data(isp->client, reg + 0, bits);
 }
 static inline int
 isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 {
-        return i2c_smbus_write_byte_data(&isp->client, reg + 1, bits);
+        return i2c_smbus_write_byte_data(isp->client, reg + 1, bits);
 }
 /*-------------------------------------------------------------------------*/
@@ -349,10 +340,10 @@ isp1301_defer_work(struct isp1301 *isp, int work)
        int status;
        if (isp && !test_and_set_bit(work, &isp->todo)) {
-                (void) get_device(&isp->client.dev);
+                (void) get_device(&isp->client->dev);
                status = schedule_work(&isp->work);
                if (!status && !isp->working)
-                        dev_vdbg(&isp->client.dev,
+                        dev_vdbg(&isp->client->dev,
                                "work item %d may be lost\n", work);
        }
 }
@@ -1135,7 +1126,7 @@ isp1301_work(struct work_struct *work)
                /* transfer state from otg engine to isp1301 */
                if (test_and_clear_bit(WORK_UPDATE_ISP, &isp->todo)) {
                        otg_update_isp(isp);
-                        put_device(&isp->client.dev);
+                        put_device(&isp->client->dev);
                }
 #endif
                /* transfer state from isp1301 to otg engine */
@@ -1143,7 +1134,7 @@ isp1301_work(struct work_struct *work)
                        u8              stat = isp1301_clear_latch(isp);
                        isp_update_otg(isp, stat);
-                        put_device(&isp->client.dev);
+                        put_device(&isp->client->dev);
                }
                if (test_and_clear_bit(WORK_HOST_RESUME, &isp->todo)) {
@@ -1178,7 +1169,7 @@ isp1301_work(struct work_struct *work)
                        }
                        host_resume(isp);
                        // mdelay(10);
-                        put_device(&isp->client.dev);
+                        put_device(&isp->client->dev);
                }
                if (test_and_clear_bit(WORK_TIMER, &isp->todo)) {
@@ -1187,15 +1178,15 @@ isp1301_work(struct work_struct *work)
                        if (!stop)
                                mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
 #endif
-                        put_device(&isp->client.dev);
+                        put_device(&isp->client->dev);
                }
                if (isp->todo)
-                        dev_vdbg(&isp->client.dev,
+                        dev_vdbg(&isp->client->dev,
                                "work done, todo = 0x%lx\n",
                                isp->todo);
                if (stop) {
-                        dev_dbg(&isp->client.dev, "stop\n");
+                        dev_dbg(&isp->client->dev, "stop\n");
                        break;
                }
        } while (isp->todo);
@@ -1219,7 +1210,7 @@ static void isp1301_release(struct device *dev)
 {
        struct isp1301  *isp;
-        isp = container_of(dev, struct isp1301, client.dev);
+        isp = dev_get_drvdata(dev);
        /* ugly -- i2c hijacks our memory hook to wait_for_completion() */
        if (isp->i2c_release)
@@ -1229,15 +1220,15 @@ static void isp1301_release(struct device *dev)
 static struct isp1301 *the_transceiver;
-static int isp1301_detach_client(struct i2c_client *i2c)
+static int __exit isp1301_remove(struct i2c_client *i2c)
 {
        struct isp1301  *isp;
-        isp = container_of(i2c, struct isp1301, client);
+        isp = i2c_get_clientdata(i2c);
        isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
        isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
-        free_irq(isp->irq, isp);
+        free_irq(i2c->irq, isp);
 #ifdef  CONFIG_USB_OTG
        otg_unbind(isp);
 #endif
@@ -1252,7 +1243,7 @@ static int isp1301_detach_client(struct i2c_client *i2c)
        put_device(&i2c->dev);
        the_transceiver = 0;
-        return i2c_detach_client(i2c);
+        return 0;
 }
 /*-------------------------------------------------------------------------*/
@@ -1285,7 +1276,7 @@ static int isp1301_otg_enable(struct isp1301 *isp)
        isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
                INTR_VBUS_VLD | INTR_SESS_VLD | INTR_ID_GND);
-        dev_info(&isp->client.dev, "ready for dual-role USB ...\n");
+        dev_info(&isp->client->dev, "ready for dual-role USB ...\n");
        return 0;
 }
@@ -1310,7 +1301,7 @@ isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
 #ifdef  CONFIG_USB_OTG
        isp->otg.host = host;
-        dev_dbg(&isp->client.dev, "registered host\n");
+        dev_dbg(&isp->client->dev, "registered host\n");
        host_suspend(isp);
        if (isp->otg.gadget)
                return isp1301_otg_enable(isp);
@@ -1325,7 +1316,7 @@ isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
        if (machine_is_omap_h2())
                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
-        dev_info(&isp->client.dev, "A-Host sessions ok\n");
+        dev_info(&isp->client->dev, "A-Host sessions ok\n");
        isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
                INTR_ID_GND);
        isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
@@ -1343,7 +1334,7 @@ isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
        return 0;
 #else
-        dev_dbg(&isp->client.dev, "host sessions not allowed\n");
+        dev_dbg(&isp->client->dev, "host sessions not allowed\n");
        return -EINVAL;
 #endif
@@ -1370,7 +1361,7 @@ isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
 #ifdef  CONFIG_USB_OTG
        isp->otg.gadget = gadget;
-        dev_dbg(&isp->client.dev, "registered gadget\n");
+        dev_dbg(&isp->client->dev, "registered gadget\n");
        /* gadget driver may be suspended until vbus_connect () */
        if (isp->otg.host)
                return isp1301_otg_enable(isp);
@@ -1395,7 +1386,7 @@ isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
                INTR_SESS_VLD);
        isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
                INTR_VBUS_VLD);
-        dev_info(&isp->client.dev, "B-Peripheral sessions ok\n");
+        dev_info(&isp->client->dev, "B-Peripheral sessions ok\n");
        dump_regs(isp, __func__);
        /* If this has a Mini-AB connector, this mode is highly
@@ -1408,7 +1399,7 @@ isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
        return 0;
 #else
-        dev_dbg(&isp->client.dev, "peripheral sessions not allowed\n");
+        dev_dbg(&isp->client->dev, "peripheral sessions not allowed\n");
        return -EINVAL;
 #endif
 }
@@ -1508,12 +1499,10 @@ isp1301_start_hnp(struct otg_transceiver *dev)
 /*-------------------------------------------------------------------------*/
-/* no error returns, they'd just make bus scanning stop */
+static int __init isp1301_probe(struct i2c_client *i2c)
-static int isp1301_probe(struct i2c_adapter *bus, int address, int kind)
 {
        int                     status;
        struct isp1301          *isp;
-        struct i2c_client       *i2c;
        if (the_transceiver)
                return 0;
@@ -1527,37 +1516,19 @@ static int isp1301_probe(struct i2c_adapter *bus, int address, int kind)
        isp->timer.function = isp1301_timer;
        isp->timer.data = (unsigned long) isp;
-        isp->irq = -1;
+        i2c_set_clientdata(i2c, isp);
-        isp->client.addr = address;
+        isp->client = i2c;
-        i2c_set_clientdata(&isp->client, isp);
-        isp->client.adapter = bus;
-        isp->client.driver = &isp1301_driver;
-        strlcpy(isp->client.name, DRIVER_NAME, I2C_NAME_SIZE);
-        i2c = &isp->client;
-        /* if this is a true probe, verify the chip ... */
-        if (kind < 0) {
-                status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
-                if (status != I2C_VENDOR_ID_PHILIPS) {
-                        dev_dbg(&bus->dev, "addr %d not philips id: %d\n",
-                                address, status);
-                        goto fail1;
-                }
-                status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
-                if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
-                        dev_dbg(&bus->dev, "%d not isp1301, %d\n",
-                                address, status);
-                        goto fail1;
-                }
-        }
-        status = i2c_attach_client(i2c);
+        /* verify the chip (shouldn't be necesary) */
-        if (status < 0) {
+        status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
-                dev_dbg(&bus->dev, "can't attach %s to device %d, err %d\n",
+        if (status != I2C_VENDOR_ID_PHILIPS) {
-                                DRIVER_NAME, address, status);
+                dev_dbg(&i2c->dev, "not philips id: %d\n", status);
-fail1:
+                goto fail;
-                kfree(isp);
+        }
-                return 0;
+        status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
+        if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
+                dev_dbg(&i2c->dev, "not isp1301, %d\n", status);
+                goto fail;
        }
        isp->i2c_release = i2c->dev.release;
        i2c->dev.release = isp1301_release;
@@ -1586,7 +1557,7 @@ fail1:
        status = otg_bind(isp);
        if (status < 0) {
                dev_dbg(&i2c->dev, "can't bind OTG\n");
-                goto fail2;
+                goto fail;
        }
 #endif
@@ -1599,26 +1570,21 @@ fail1:
                /* IRQ wired at M14 */
                omap_cfg_reg(M14_1510_GPIO2);
-                isp->irq = OMAP_GPIO_IRQ(2);
                if (gpio_request(2, "isp1301") == 0)
                        gpio_direction_input(2);
                isp->irq_type = IRQF_TRIGGER_FALLING;
        }
        isp->irq_type |= IRQF_SAMPLE_RANDOM;
-        status = request_irq(isp->irq, isp1301_irq,
+        status = request_irq(i2c->irq, isp1301_irq,
                        isp->irq_type, DRIVER_NAME, isp);
        if (status < 0) {
                dev_dbg(&i2c->dev, "can't get IRQ %d, err %d\n",
-                                isp->irq, status);
+                                i2c->irq, status);
-#ifdef  CONFIG_USB_OTG
+                goto fail;
-fail2:
-#endif
-                i2c_detach_client(i2c);
-                goto fail1;
        }
-        isp->otg.dev = &isp->client.dev;
+        isp->otg.dev = &i2c->dev;
        isp->otg.label = DRIVER_NAME;
        isp->otg.set_host = isp1301_set_host,
@@ -1649,22 +1615,25 @@ fail2:
                        status);
        return 0;
-}
-static int isp1301_scan_bus(struct i2c_adapter *bus)
+fail:
-{
+        kfree(isp);
-        if (!i2c_check_functionality(bus, I2C_FUNC_SMBUS_BYTE_DATA
+        return -ENODEV;
-                        | I2C_FUNC_SMBUS_READ_WORD_DATA))
-                return -EINVAL;
-        return i2c_probe(bus, &addr_data, isp1301_probe);
 }
+static const struct i2c_device_id isp1301_id[] = {
+        { "isp1301_omap", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, isp1301_id);
 static struct i2c_driver isp1301_driver = {
        .driver = {
                .name   = "isp1301_omap",
        },
-        .attach_adapter = isp1301_scan_bus,
+        .probe          = isp1301_probe,
-        .detach_client  = isp1301_detach_client,
+        .remove         = __exit_p(isp1301_remove),
+        .id_table       = isp1301_id,
 };
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/i2c/chips/tps65010.c b/drivers/i2c/chips/tps65010.c
index cf02e8fceb42..acf8b9d5f575 100644
--- a/drivers/i2c/chips/tps65010.c
+++ b/drivers/i2c/chips/tps65010.c
@@ -456,14 +456,17 @@ static irqreturn_t tps65010_irq(int irq, void *_tps)
 /* offsets 0..3 == GPIO1..GPIO4
 * offsets 4..5 == LED1/nPG, LED2 (we set one of the non-BLINK modes)
+ * offset 6 == vibrator motor driver
 */
 static void
 tps65010_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
        if (offset < 4)
                tps65010_set_gpio_out_value(offset + 1, value);
-        else
+        else if (offset < 6)
                tps65010_set_led(offset - 3, value ? ON : OFF);
+        else
+                tps65010_set_vib(value);
 }
 static int
@@ -477,8 +480,10 @@ tps65010_output(struct gpio_chip *chip, unsigned offset, int value)
                if (!(tps->outmask & (1 << offset)))
                        return -EINVAL;
                tps65010_set_gpio_out_value(offset + 1, value);
-        } else
+        } else if (offset < 6)
                tps65010_set_led(offset - 3, value ? ON : OFF);
+        else
+                tps65010_set_vib(value);
        return 0;
 }
@@ -646,7 +651,7 @@ static int tps65010_probe(struct i2c_client *client,
                tps->chip.get = tps65010_gpio_get;
                tps->chip.base = board->base;
-                tps->chip.ngpio = 6;
+                tps->chip.ngpio = 7;
                tps->chip.can_sleep = 1;
                status = gpiochip_add(&tps->chip);
@@ -675,6 +680,7 @@ static const struct i2c_device_id tps65010_id[] = {
        { "tps65011", TPS65011 },
        { "tps65012", TPS65012 },
        { "tps65013", TPS65013 },
+        { "tps65014", TPS65011 },       /* tps65011 charging at 6.5V max */
        { }
 };
 MODULE_DEVICE_TABLE(i2c, tps65010_id);
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index b346a687ab59..42e852d79ffa 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -437,6 +437,10 @@ static int i2c_register_adapter(struct i2c_adapter *adap)
 {
        int res = 0, dummy;
+        /* Can't register until after driver model init */
+        if (unlikely(WARN_ON(!i2c_bus_type.p)))
+                return -EAGAIN;
        mutex_init(&adap->bus_lock);
        mutex_init(&adap->clist_lock);
        INIT_LIST_HEAD(&adap->clients);
@@ -696,6 +700,10 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 {
        int res;
+        /* Can't register until after driver model init */
+        if (unlikely(WARN_ON(!i2c_bus_type.p)))
+                return -EAGAIN;
        /* new style driver methods can't mix with legacy ones */
        if (is_newstyle_driver(driver)) {
                if (driver->attach_adapter || driver->detach_adapter
@@ -978,7 +986,10 @@ static void __exit i2c_exit(void)
        bus_unregister(&i2c_bus_type);
 }
-subsys_initcall(i2c_init);
+/* We must initialize early, because some subsystems register i2c drivers
+ * in subsys_initcall() code, but are linked (and initialized) before i2c.
+ */
+postcore_initcall(i2c_init);
 module_exit(i2c_exit);
 /* ----------------------------------------------------
@@ -1677,6 +1688,28 @@ s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
 EXPORT_SYMBOL(i2c_smbus_write_word_data);
 /**
+ * i2c_smbus_process_call - SMBus "process call" protocol
+ * @client: Handle to slave device
+ * @command: Byte interpreted by slave
+ * @value: 16-bit "word" being written
+ *
+ * This executes the SMBus "process call" protocol, returning negative errno
+ * else a 16-bit unsigned "word" received from the device.
+ */
+s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
+{
+        union i2c_smbus_data data;
+        int status;
+        data.word = value;
+        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
+                                I2C_SMBUS_WRITE, command,
+                                I2C_SMBUS_PROC_CALL, &data);
+        return (status < 0) ? status : data.word;
+}
+EXPORT_SYMBOL(i2c_smbus_process_call);
+/**
 * i2c_smbus_read_block_data - SMBus "block read" protocol
 * @client: Handle to slave device
 * @command: Byte interpreted by slave
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index b23af0c2a869..963ad0b6a4e9 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -913,6 +913,92 @@ static inline int cmos_poweroff(struct device *dev)
 * predate even PNPBIOS should set up platform_bus devices.
 */
+#ifdef  CONFIG_ACPI
+#include <linux/acpi.h>
+#ifdef  CONFIG_PM
+static u32 rtc_handler(void *context)
+{
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+        return ACPI_INTERRUPT_HANDLED;
+}
+static inline void rtc_wake_setup(void)
+{
+        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
+        /*
+         * After the RTC handler is installed, the Fixed_RTC event should
+         * be disabled. Only when the RTC alarm is set will it be enabled.
+         */
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+}
+static void rtc_wake_on(struct device *dev)
+{
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_enable_event(ACPI_EVENT_RTC, 0);
+}
+static void rtc_wake_off(struct device *dev)
+{
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+}
+#else
+#define rtc_wake_setup()        do{}while(0)
+#define rtc_wake_on             NULL
+#define rtc_wake_off            NULL
+#endif
+/* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
+ * its device node and pass extra config data.  This helps its driver use
+ * capabilities that the now-obsolete mc146818 didn't have, and informs it
+ * that this board's RTC is wakeup-capable (per ACPI spec).
+ */
+static struct cmos_rtc_board_info acpi_rtc_info;
+static void __devinit
+cmos_wake_setup(struct device *dev)
+{
+        if (acpi_disabled)
+                return;
+        rtc_wake_setup();
+        acpi_rtc_info.wake_on = rtc_wake_on;
+        acpi_rtc_info.wake_off = rtc_wake_off;
+        /* workaround bug in some ACPI tables */
+        if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
+                dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
+                        acpi_gbl_FADT.month_alarm);
+                acpi_gbl_FADT.month_alarm = 0;
+        }
+        acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
+        acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
+        acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
+        /* NOTE:  S4_RTC_WAKE is NOT currently useful to Linux */
+        if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
+                dev_info(dev, "RTC can wake from S4\n");
+        dev->platform_data = &acpi_rtc_info;
+        /* RTC always wakes from S1/S2/S3, and often S4/STD */
+        device_init_wakeup(dev, 1);
+}
+#else
+static void __devinit
+cmos_wake_setup(struct device *dev)
+{
+}
+#endif
 #ifdef  CONFIG_PNP
 #include <linux/pnp.h>
@@ -920,6 +1006,8 @@ static inline int cmos_poweroff(struct device *dev)
 static int __devinit
 cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
 {
+        cmos_wake_setup(&pnp->dev);
        if (pnp_port_start(pnp,0) == 0x70 && !pnp_irq_valid(pnp,0))
                /* Some machines contain a PNP entry for the RTC, but
                 * don't define the IRQ. It should always be safe to
@@ -997,6 +1085,7 @@ static struct pnp_driver cmos_pnp_driver = {
 static int __init cmos_platform_probe(struct platform_device *pdev)
 {
+        cmos_wake_setup(&pdev->dev);
        return cmos_do_probe(&pdev->dev,
                        platform_get_resource(pdev, IORESOURCE_IO, 0),
                        platform_get_irq(pdev, 0));
@@ -1031,29 +1120,32 @@ static struct platform_driver cmos_platform_driver = {
 static int __init cmos_init(void)
 {
+        int retval = 0;
 #ifdef  CONFIG_PNP
-        if (pnp_platform_devices)
+        pnp_register_driver(&cmos_pnp_driver);
-                return pnp_register_driver(&cmos_pnp_driver);
+#endif
-        else
-                return platform_driver_probe(&cmos_platform_driver,
+        if (!cmos_rtc.dev)
-                        cmos_platform_probe);
+                retval = platform_driver_probe(&cmos_platform_driver,
-#else
+                                               cmos_platform_probe);
-        return platform_driver_probe(&cmos_platform_driver,
-                        cmos_platform_probe);
+        if (retval == 0)
-#endif /* CONFIG_PNP */
+                return 0;
+#ifdef  CONFIG_PNP
+        pnp_unregister_driver(&cmos_pnp_driver);
+#endif
+        return retval;
 }
 module_init(cmos_init);
 static void __exit cmos_exit(void)
 {
 #ifdef  CONFIG_PNP
-        if (pnp_platform_devices)
+        pnp_unregister_driver(&cmos_pnp_driver);
-                pnp_unregister_driver(&cmos_pnp_driver);
+#endif
-        else
-                platform_driver_unregister(&cmos_platform_driver);
-#else
        platform_driver_unregister(&cmos_platform_driver);
-#endif /* CONFIG_PNP */
 }
 module_exit(cmos_exit);
diff --git a/fs/Kconfig b/fs/Kconfig
index 501f012e0c6f..9e9d70c02a07 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -220,17 +220,16 @@ config JBD
        tristate
        help
          This is a generic journalling layer for block devices.  It is
-          currently used by the ext3 and OCFS2 file systems, but it could
+          currently used by the ext3 file system, but it could also be
-          also be used to add journal support to other file systems or block
+          used to add journal support to other file systems or block
          devices such as RAID or LVM.
-          If you are using the ext3 or OCFS2 file systems, you need to
+          If you are using the ext3 file system, you need to say Y here.
-          say Y here. If you are not using ext3 OCFS2 then you will probably
+          If you are not using ext3 then you will probably want to say N.
-          want to say N.
          To compile this device as a module, choose M here: the module will be
-          called jbd.  If you are compiling ext3 or OCFS2 into the kernel,
+          called jbd.  If you are compiling ext3 into the kernel, you
-          you cannot compile this code as a module.
+          cannot compile this code as a module.
 config JBD_DEBUG
        bool "JBD (ext3) debugging support"
@@ -254,15 +253,16 @@ config JBD2
        help
          This is a generic journaling layer for block devices that support
          both 32-bit and 64-bit block numbers.  It is currently used by
-          the ext4 filesystem, but it could also be used to add
+          the ext4 and OCFS2 filesystems, but it could also be used to add
          journal support to other file systems or block devices such
          as RAID or LVM.
-          If you are using ext4, you need to say Y here. If you are not
+          If you are using ext4 or OCFS2, you need to say Y here.
-          using ext4 then you will probably want to say N.
+          If you are not using ext4 or OCFS2 then you will
+          probably want to say N.
          To compile this device as a module, choose M here. The module will be
-          called jbd2.  If you are compiling ext4 into the kernel,
+          called jbd2.  If you are compiling ext4 or OCFS2 into the kernel,
          you cannot compile this code as a module.
 config JBD2_DEBUG
@@ -448,7 +448,7 @@ config OCFS2_FS
        tristate "OCFS2 file system support"
        depends on NET && SYSFS
        select CONFIGFS_FS
-        select JBD
+        select JBD2
        select CRC32
        help
          OCFS2 is a general purpose extent based shared disk cluster file
@@ -519,6 +519,16 @@ config OCFS2_DEBUG_FS
          this option for debugging only as it is likely to decrease
          performance of the filesystem.
+config OCFS2_COMPAT_JBD
+        bool "Use JBD for compatibility"
+        depends on OCFS2_FS
+        default n
+        select JBD
+        help
+          The ocfs2 filesystem now uses JBD2 for its journalling.  JBD2
+          is backwards compatible with JBD.  It is safe to say N here.
+          However, if you really want to use the original JBD, say Y here.
 endif # BLOCK
 config DNOTIFY
diff --git a/fs/ocfs2/Makefile b/fs/ocfs2/Makefile
index f6956de56fdb..589dcdfdfe3c 100644
--- a/fs/ocfs2/Makefile
+++ b/fs/ocfs2/Makefile
@@ -34,7 +34,8 @@ ocfs2-objs := \
        symlink.o               \
        sysfile.o               \
        uptodate.o              \
-        ver.o
+        ver.o                   \
+        xattr.o
 ocfs2_stackglue-objs := stackglue.o
 ocfs2_stack_o2cb-objs := stack_o2cb.o
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index 29ff57ec5d1f..0cc2deb9394c 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -49,6 +49,340 @@
 #include "buffer_head_io.h"
+/*
+ * Operations for a specific extent tree type.
+ *
+ * To implement an on-disk btree (extent tree) type in ocfs2, add
+ * an ocfs2_extent_tree_operations structure and the matching
+ * ocfs2_init_<thingy>_extent_tree() function.  That's pretty much it
+ * for the allocation portion of the extent tree.
+ */
+struct ocfs2_extent_tree_operations {
+        /*
+         * last_eb_blk is the block number of the right most leaf extent
+         * block.  Most on-disk structures containing an extent tree store
+         * this value for fast access.  The ->eo_set_last_eb_blk() and
+         * ->eo_get_last_eb_blk() operations access this value.  They are
+         *  both required.
+         */
+        void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
+                                   u64 blkno);
+        u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
+        /*
+         * The on-disk structure usually keeps track of how many total
+         * clusters are stored in this extent tree.  This function updates
+         * that value.  new_clusters is the delta, and must be
+         * added to the total.  Required.
+         */
+        void (*eo_update_clusters)(struct inode *inode,
+                                   struct ocfs2_extent_tree *et,
+                                   u32 new_clusters);
+        /*
+         * If ->eo_insert_check() exists, it is called before rec is
+         * inserted into the extent tree.  It is optional.
+         */
+        int (*eo_insert_check)(struct inode *inode,
+                               struct ocfs2_extent_tree *et,
+                               struct ocfs2_extent_rec *rec);
+        int (*eo_sanity_check)(struct inode *inode, struct ocfs2_extent_tree *et);
+        /*
+         * --------------------------------------------------------------
+         * The remaining are internal to ocfs2_extent_tree and don't have
+         * accessor functions
+         */
+        /*
+         * ->eo_fill_root_el() takes et->et_object and sets et->et_root_el.
+         * It is required.
+         */
+        void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
+        /*
+         * ->eo_fill_max_leaf_clusters sets et->et_max_leaf_clusters if
+         * it exists.  If it does not, et->et_max_leaf_clusters is set
+         * to 0 (unlimited).  Optional.
+         */
+        void (*eo_fill_max_leaf_clusters)(struct inode *inode,
+                                          struct ocfs2_extent_tree *et);
+};
+/*
+ * Pre-declare ocfs2_dinode_et_ops so we can use it as a sanity check
+ * in the methods.
+ */
+static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et);
+static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
+                                         u64 blkno);
+static void ocfs2_dinode_update_clusters(struct inode *inode,
+                                         struct ocfs2_extent_tree *et,
+                                         u32 clusters);
+static int ocfs2_dinode_insert_check(struct inode *inode,
+                                     struct ocfs2_extent_tree *et,
+                                     struct ocfs2_extent_rec *rec);
+static int ocfs2_dinode_sanity_check(struct inode *inode,
+                                     struct ocfs2_extent_tree *et);
+static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et);
+static struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
+        .eo_set_last_eb_blk     = ocfs2_dinode_set_last_eb_blk,
+        .eo_get_last_eb_blk     = ocfs2_dinode_get_last_eb_blk,
+        .eo_update_clusters     = ocfs2_dinode_update_clusters,
+        .eo_insert_check        = ocfs2_dinode_insert_check,
+        .eo_sanity_check        = ocfs2_dinode_sanity_check,
+        .eo_fill_root_el        = ocfs2_dinode_fill_root_el,
+};
+static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
+                                         u64 blkno)
+{
+        struct ocfs2_dinode *di = et->et_object;
+        BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
+        di->i_last_eb_blk = cpu_to_le64(blkno);
+}
+static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
+{
+        struct ocfs2_dinode *di = et->et_object;
+        BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
+        return le64_to_cpu(di->i_last_eb_blk);
+}
+static void ocfs2_dinode_update_clusters(struct inode *inode,
+                                         struct ocfs2_extent_tree *et,
+                                         u32 clusters)
+{
+        struct ocfs2_dinode *di = et->et_object;
+        le32_add_cpu(&di->i_clusters, clusters);
+        spin_lock(&OCFS2_I(inode)->ip_lock);
+        OCFS2_I(inode)->ip_clusters = le32_to_cpu(di->i_clusters);
+        spin_unlock(&OCFS2_I(inode)->ip_lock);
+}
+static int ocfs2_dinode_insert_check(struct inode *inode,
+                                     struct ocfs2_extent_tree *et,
+                                     struct ocfs2_extent_rec *rec)
+{
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        BUG_ON(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL);
+        mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
+                        (OCFS2_I(inode)->ip_clusters != rec->e_cpos),
+                        "Device %s, asking for sparse allocation: inode %llu, "
+                        "cpos %u, clusters %u\n",
+                        osb->dev_str,
+                        (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                        rec->e_cpos,
+                        OCFS2_I(inode)->ip_clusters);
+        return 0;
+}
+static int ocfs2_dinode_sanity_check(struct inode *inode,
+                                     struct ocfs2_extent_tree *et)
+{
+        int ret = 0;
+        struct ocfs2_dinode *di;
+        BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
+        di = et->et_object;
+        if (!OCFS2_IS_VALID_DINODE(di)) {
+                ret = -EIO;
+                ocfs2_error(inode->i_sb,
+                        "Inode %llu has invalid path root",
+                        (unsigned long long)OCFS2_I(inode)->ip_blkno);
+        }
+        return ret;
+}
+static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
+{
+        struct ocfs2_dinode *di = et->et_object;
+        et->et_root_el = &di->id2.i_list;
+}
+static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
+{
+        struct ocfs2_xattr_value_root *xv = et->et_object;
+        et->et_root_el = &xv->xr_list;
+}
+static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
+                                              u64 blkno)
+{
+        struct ocfs2_xattr_value_root *xv =
+                (struct ocfs2_xattr_value_root *)et->et_object;
+        xv->xr_last_eb_blk = cpu_to_le64(blkno);
+}
+static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
+{
+        struct ocfs2_xattr_value_root *xv =
+                (struct ocfs2_xattr_value_root *) et->et_object;
+        return le64_to_cpu(xv->xr_last_eb_blk);
+}
+static void ocfs2_xattr_value_update_clusters(struct inode *inode,
+                                              struct ocfs2_extent_tree *et,
+                                              u32 clusters)
+{
+        struct ocfs2_xattr_value_root *xv =
+                (struct ocfs2_xattr_value_root *)et->et_object;
+        le32_add_cpu(&xv->xr_clusters, clusters);
+}
+static struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = {
+        .eo_set_last_eb_blk     = ocfs2_xattr_value_set_last_eb_blk,
+        .eo_get_last_eb_blk     = ocfs2_xattr_value_get_last_eb_blk,
+        .eo_update_clusters     = ocfs2_xattr_value_update_clusters,
+        .eo_fill_root_el        = ocfs2_xattr_value_fill_root_el,
+};
+static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
+{
+        struct ocfs2_xattr_block *xb = et->et_object;
+        et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
+}
+static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct inode *inode,
+                                                    struct ocfs2_extent_tree *et)
+{
+        et->et_max_leaf_clusters =
+                ocfs2_clusters_for_bytes(inode->i_sb,
+                                         OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
+}
+static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
+                                             u64 blkno)
+{
+        struct ocfs2_xattr_block *xb = et->et_object;
+        struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
+        xt->xt_last_eb_blk = cpu_to_le64(blkno);
+}
+static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
+{
+        struct ocfs2_xattr_block *xb = et->et_object;
+        struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
+        return le64_to_cpu(xt->xt_last_eb_blk);
+}
+static void ocfs2_xattr_tree_update_clusters(struct inode *inode,
+                                             struct ocfs2_extent_tree *et,
+                                             u32 clusters)
+{
+        struct ocfs2_xattr_block *xb = et->et_object;
+        le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters);
+}
+static struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
+        .eo_set_last_eb_blk     = ocfs2_xattr_tree_set_last_eb_blk,
+        .eo_get_last_eb_blk     = ocfs2_xattr_tree_get_last_eb_blk,
+        .eo_update_clusters     = ocfs2_xattr_tree_update_clusters,
+        .eo_fill_root_el        = ocfs2_xattr_tree_fill_root_el,
+        .eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters,
+};
+static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et,
+                                     struct inode *inode,
+                                     struct buffer_head *bh,
+                                     void *obj,
+                                     struct ocfs2_extent_tree_operations *ops)
+{
+        et->et_ops = ops;
+        et->et_root_bh = bh;
+        if (!obj)
+                obj = (void *)bh->b_data;
+        et->et_object = obj;
+        et->et_ops->eo_fill_root_el(et);
+        if (!et->et_ops->eo_fill_max_leaf_clusters)
+                et->et_max_leaf_clusters = 0;
+        else
+                et->et_ops->eo_fill_max_leaf_clusters(inode, et);
+}
+void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
+                                   struct inode *inode,
+                                   struct buffer_head *bh)
+{
+        __ocfs2_init_extent_tree(et, inode, bh, NULL, &ocfs2_dinode_et_ops);
+}
+void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
+                                       struct inode *inode,
+                                       struct buffer_head *bh)
+{
+        __ocfs2_init_extent_tree(et, inode, bh, NULL,
+                                 &ocfs2_xattr_tree_et_ops);
+}
+void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
+                                        struct inode *inode,
+                                        struct buffer_head *bh,
+                                        struct ocfs2_xattr_value_root *xv)
+{
+        __ocfs2_init_extent_tree(et, inode, bh, xv,
+                                 &ocfs2_xattr_value_et_ops);
+}
+static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
+                                            u64 new_last_eb_blk)
+{
+        et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
+}
+static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
+{
+        return et->et_ops->eo_get_last_eb_blk(et);
+}
+static inline void ocfs2_et_update_clusters(struct inode *inode,
+                                            struct ocfs2_extent_tree *et,
+                                            u32 clusters)
+{
+        et->et_ops->eo_update_clusters(inode, et, clusters);
+}
+static inline int ocfs2_et_insert_check(struct inode *inode,
+                                        struct ocfs2_extent_tree *et,
+                                        struct ocfs2_extent_rec *rec)
+{
+        int ret = 0;
+        if (et->et_ops->eo_insert_check)
+                ret = et->et_ops->eo_insert_check(inode, et, rec);
+        return ret;
+}
+static inline int ocfs2_et_sanity_check(struct inode *inode,
+                                        struct ocfs2_extent_tree *et)
+{
+        int ret = 0;
+        if (et->et_ops->eo_sanity_check)
+                ret = et->et_ops->eo_sanity_check(inode, et);
+        return ret;
+}
 static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc);
 static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
                                         struct ocfs2_extent_block *eb);
@@ -205,17 +539,6 @@ static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
 }
 /*
- * Allocate and initialize a new path based on a disk inode tree.
- */
-static struct ocfs2_path *ocfs2_new_inode_path(struct buffer_head *di_bh)
-{
-        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
-        struct ocfs2_extent_list *el = &di->id2.i_list;
-        return ocfs2_new_path(di_bh, el);
-}
-/*
 * Convenience function to journal all components in a path.
 */
 static int ocfs2_journal_access_path(struct inode *inode, handle_t *handle,
@@ -368,39 +691,35 @@ struct ocfs2_merge_ctxt {
 */
 int ocfs2_num_free_extents(struct ocfs2_super *osb,
                           struct inode *inode,
-                           struct ocfs2_dinode *fe)
+                           struct ocfs2_extent_tree *et)
 {
        int retval;
-        struct ocfs2_extent_list *el;
+        struct ocfs2_extent_list *el = NULL;
        struct ocfs2_extent_block *eb;
        struct buffer_head *eb_bh = NULL;
+        u64 last_eb_blk = 0;
        mlog_entry_void();
-        if (!OCFS2_IS_VALID_DINODE(fe)) {
+        el = et->et_root_el;
-                OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
+        last_eb_blk = ocfs2_et_get_last_eb_blk(et);
-                retval = -EIO;
-                goto bail;
-        }
-        if (fe->i_last_eb_blk) {
+        if (last_eb_blk) {
-                retval = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
+                retval = ocfs2_read_block(inode, last_eb_blk,
-                                          &eb_bh, OCFS2_BH_CACHED, inode);
+                                          &eb_bh);
                if (retval < 0) {
                        mlog_errno(retval);
                        goto bail;
                }
                eb = (struct ocfs2_extent_block *) eb_bh->b_data;
                el = &eb->h_list;
-        } else
+        }
-                el = &fe->id2.i_list;
        BUG_ON(el->l_tree_depth != 0);
        retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
 bail:
-        if (eb_bh)
+        brelse(eb_bh);
-                brelse(eb_bh);
        mlog_exit(retval);
        return retval;
@@ -486,8 +805,7 @@ static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
 bail:
        if (status < 0) {
                for(i = 0; i < wanted; i++) {
-                        if (bhs[i])
+                        brelse(bhs[i]);
-                                brelse(bhs[i]);
                        bhs[i] = NULL;
                }
        }
@@ -531,7 +849,7 @@ static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list  *el)
 static int ocfs2_add_branch(struct ocfs2_super *osb,
                            handle_t *handle,
                            struct inode *inode,
-                            struct buffer_head *fe_bh,
+                            struct ocfs2_extent_tree *et,
                            struct buffer_head *eb_bh,
                            struct buffer_head **last_eb_bh,
                            struct ocfs2_alloc_context *meta_ac)
@@ -540,7 +858,6 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
        u64 next_blkno, new_last_eb_blk;
        struct buffer_head *bh;
        struct buffer_head **new_eb_bhs = NULL;
-        struct ocfs2_dinode *fe;
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list  *eb_el;
        struct ocfs2_extent_list  *el;
@@ -550,13 +867,11 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
        BUG_ON(!last_eb_bh || !*last_eb_bh);
-        fe = (struct ocfs2_dinode *) fe_bh->b_data;
        if (eb_bh) {
                eb = (struct ocfs2_extent_block *) eb_bh->b_data;
                el = &eb->h_list;
        } else
-                el = &fe->id2.i_list;
+                el = et->et_root_el;
        /* we never add a branch to a leaf. */
        BUG_ON(!el->l_tree_depth);
@@ -646,7 +961,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
                mlog_errno(status);
                goto bail;
        }
-        status = ocfs2_journal_access(handle, inode, fe_bh,
+        status = ocfs2_journal_access(handle, inode, et->et_root_bh,
                                      OCFS2_JOURNAL_ACCESS_WRITE);
        if (status < 0) {
                mlog_errno(status);
@@ -662,7 +977,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
        }
        /* Link the new branch into the rest of the tree (el will
-         * either be on the fe, or the extent block passed in. */
+         * either be on the root_bh, or the extent block passed in. */
        i = le16_to_cpu(el->l_next_free_rec);
        el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
        el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
@@ -671,7 +986,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
        /* fe needs a new last extent block pointer, as does the
         * next_leaf on the previously last-extent-block. */
-        fe->i_last_eb_blk = cpu_to_le64(new_last_eb_blk);
+        ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
        eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
        eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
@@ -679,7 +994,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
        status = ocfs2_journal_dirty(handle, *last_eb_bh);
        if (status < 0)
                mlog_errno(status);
-        status = ocfs2_journal_dirty(handle, fe_bh);
+        status = ocfs2_journal_dirty(handle, et->et_root_bh);
        if (status < 0)
                mlog_errno(status);
        if (eb_bh) {
@@ -700,8 +1015,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
 bail:
        if (new_eb_bhs) {
                for (i = 0; i < new_blocks; i++)
-                        if (new_eb_bhs[i])
+                        brelse(new_eb_bhs[i]);
-                                brelse(new_eb_bhs[i]);
                kfree(new_eb_bhs);
        }
@@ -717,16 +1031,15 @@ bail:
 static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
                                  handle_t *handle,
                                  struct inode *inode,
-                                  struct buffer_head *fe_bh,
+                                  struct ocfs2_extent_tree *et,
                                  struct ocfs2_alloc_context *meta_ac,
                                  struct buffer_head **ret_new_eb_bh)
 {
        int status, i;
        u32 new_clusters;
        struct buffer_head *new_eb_bh = NULL;
-        struct ocfs2_dinode *fe;
        struct ocfs2_extent_block *eb;
-        struct ocfs2_extent_list  *fe_el;
+        struct ocfs2_extent_list  *root_el;
        struct ocfs2_extent_list  *eb_el;
        mlog_entry_void();
@@ -746,8 +1059,7 @@ static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
        }
        eb_el = &eb->h_list;
-        fe = (struct ocfs2_dinode *) fe_bh->b_data;
+        root_el = et->et_root_el;
-        fe_el = &fe->id2.i_list;
        status = ocfs2_journal_access(handle, inode, new_eb_bh,
                                      OCFS2_JOURNAL_ACCESS_CREATE);
@@ -756,11 +1068,11 @@ static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
                goto bail;
        }
-        /* copy the fe data into the new extent block */
+        /* copy the root extent list data into the new extent block */
-        eb_el->l_tree_depth = fe_el->l_tree_depth;
+        eb_el->l_tree_depth = root_el->l_tree_depth;
-        eb_el->l_next_free_rec = fe_el->l_next_free_rec;
+        eb_el->l_next_free_rec = root_el->l_next_free_rec;
-        for(i = 0; i < le16_to_cpu(fe_el->l_next_free_rec); i++)
+        for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
-                eb_el->l_recs[i] = fe_el->l_recs[i];
+                eb_el->l_recs[i] = root_el->l_recs[i];
        status = ocfs2_journal_dirty(handle, new_eb_bh);
        if (status < 0) {
@@ -768,7 +1080,7 @@ static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
                goto bail;
        }
-        status = ocfs2_journal_access(handle, inode, fe_bh,
+        status = ocfs2_journal_access(handle, inode, et->et_root_bh,
                                      OCFS2_JOURNAL_ACCESS_WRITE);
        if (status < 0) {
                mlog_errno(status);
@@ -777,21 +1089,21 @@ static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
        new_clusters = ocfs2_sum_rightmost_rec(eb_el);
-        /* update fe now */
+        /* update root_bh now */
-        le16_add_cpu(&fe_el->l_tree_depth, 1);
+        le16_add_cpu(&root_el->l_tree_depth, 1);
-        fe_el->l_recs[0].e_cpos = 0;
+        root_el->l_recs[0].e_cpos = 0;
-        fe_el->l_recs[0].e_blkno = eb->h_blkno;
+        root_el->l_recs[0].e_blkno = eb->h_blkno;
-        fe_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
+        root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
-        for(i = 1; i < le16_to_cpu(fe_el->l_next_free_rec); i++)
+        for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
-                memset(&fe_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
+                memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
-        fe_el->l_next_free_rec = cpu_to_le16(1);
+        root_el->l_next_free_rec = cpu_to_le16(1);
        /* If this is our 1st tree depth shift, then last_eb_blk
         * becomes the allocated extent block */
-        if (fe_el->l_tree_depth == cpu_to_le16(1))
+        if (root_el->l_tree_depth == cpu_to_le16(1))
-                fe->i_last_eb_blk = eb->h_blkno;
+                ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
-        status = ocfs2_journal_dirty(handle, fe_bh);
+        status = ocfs2_journal_dirty(handle, et->et_root_bh);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -801,8 +1113,7 @@ static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
        new_eb_bh = NULL;
        status = 0;
 bail:
-        if (new_eb_bh)
+        brelse(new_eb_bh);
-                brelse(new_eb_bh);
        mlog_exit(status);
        return status;
@@ -817,22 +1128,21 @@ bail:
 * 1) a lowest extent block is found, then we pass it back in
 *    *lowest_eb_bh and return '0'
 *
- * 2) the search fails to find anything, but the dinode has room. We
+ * 2) the search fails to find anything, but the root_el has room. We
 *    pass NULL back in *lowest_eb_bh, but still return '0'
 *
- * 3) the search fails to find anything AND the dinode is full, in
+ * 3) the search fails to find anything AND the root_el is full, in
 *    which case we return > 0
 *
 * return status < 0 indicates an error.
 */
 static int ocfs2_find_branch_target(struct ocfs2_super *osb,
                                    struct inode *inode,
-                                    struct buffer_head *fe_bh,
+                                    struct ocfs2_extent_tree *et,
                                    struct buffer_head **target_bh)
 {
        int status = 0, i;
        u64 blkno;
-        struct ocfs2_dinode *fe;
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list  *el;
        struct buffer_head *bh = NULL;
@@ -842,8 +1152,7 @@ static int ocfs2_find_branch_target(struct ocfs2_super *osb,
        *target_bh = NULL;
-        fe = (struct ocfs2_dinode *) fe_bh->b_data;
+        el = et->et_root_el;
-        el = &fe->id2.i_list;
        while(le16_to_cpu(el->l_tree_depth) > 1) {
                if (le16_to_cpu(el->l_next_free_rec) == 0) {
@@ -864,13 +1173,10 @@ static int ocfs2_find_branch_target(struct ocfs2_super *osb,
                        goto bail;
                }
-                if (bh) {
+                brelse(bh);
-                        brelse(bh);
+                bh = NULL;
-                        bh = NULL;
-                }
-                status = ocfs2_read_block(osb, blkno, &bh, OCFS2_BH_CACHED,
+                status = ocfs2_read_block(inode, blkno, &bh);
-                                          inode);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
@@ -886,8 +1192,7 @@ static int ocfs2_find_branch_target(struct ocfs2_super *osb,
                if (le16_to_cpu(el->l_next_free_rec) <
                    le16_to_cpu(el->l_count)) {
-                        if (lowest_bh)
+                        brelse(lowest_bh);
-                                brelse(lowest_bh);
                        lowest_bh = bh;
                        get_bh(lowest_bh);
                }
@@ -895,14 +1200,13 @@ static int ocfs2_find_branch_target(struct ocfs2_super *osb,
        /* If we didn't find one and the fe doesn't have any room,
         * then return '1' */
-        if (!lowest_bh
+        el = et->et_root_el;
-            && (fe->id2.i_list.l_next_free_rec == fe->id2.i_list.l_count))
+        if (!lowest_bh && (el->l_next_free_rec == el->l_count))
                status = 1;
        *target_bh = lowest_bh;
 bail:
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(status);
        return status;
@@ -919,19 +1223,19 @@ bail:
 * *last_eb_bh will be updated by ocfs2_add_branch().
 */
 static int ocfs2_grow_tree(struct inode *inode, handle_t *handle,
-                           struct buffer_head *di_bh, int *final_depth,
+                           struct ocfs2_extent_tree *et, int *final_depth,
                           struct buffer_head **last_eb_bh,
                           struct ocfs2_alloc_context *meta_ac)
 {
        int ret, shift;
-        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        struct ocfs2_extent_list *el = et->et_root_el;
-        int depth = le16_to_cpu(di->id2.i_list.l_tree_depth);
+        int depth = le16_to_cpu(el->l_tree_depth);
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        struct buffer_head *bh = NULL;
        BUG_ON(meta_ac == NULL);
-        shift = ocfs2_find_branch_target(osb, inode, di_bh, &bh);
+        shift = ocfs2_find_branch_target(osb, inode, et, &bh);
        if (shift < 0) {
                ret = shift;
                mlog_errno(ret);
@@ -948,7 +1252,7 @@ static int ocfs2_grow_tree(struct inode *inode, handle_t *handle,
                /* ocfs2_shift_tree_depth will return us a buffer with
                 * the new extent block (so we can pass that to
                 * ocfs2_add_branch). */
-                ret = ocfs2_shift_tree_depth(osb, handle, inode, di_bh,
+                ret = ocfs2_shift_tree_depth(osb, handle, inode, et,
                                             meta_ac, &bh);
                if (ret < 0) {
                        mlog_errno(ret);
@@ -975,7 +1279,7 @@ static int ocfs2_grow_tree(struct inode *inode, handle_t *handle,
        /* call ocfs2_add_branch to add the final part of the tree with
         * the new data. */
        mlog(0, "add branch. bh = %p\n", bh);
-        ret = ocfs2_add_branch(osb, handle, inode, di_bh, bh, last_eb_bh,
+        ret = ocfs2_add_branch(osb, handle, inode, et, bh, last_eb_bh,
                               meta_ac);
        if (ret < 0) {
                mlog_errno(ret);
@@ -1236,8 +1540,7 @@ static int __ocfs2_find_path(struct inode *inode,
                brelse(bh);
                bh = NULL;
-                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno,
+                ret = ocfs2_read_block(inode, blkno, &bh);
-                                       &bh, OCFS2_BH_CACHED, inode);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -2058,11 +2361,11 @@ static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
                                     struct ocfs2_path *right_path,
                                     int subtree_index,
                                     struct ocfs2_cached_dealloc_ctxt *dealloc,
-                                     int *deleted)
+                                     int *deleted,
+                                     struct ocfs2_extent_tree *et)
 {
        int ret, i, del_right_subtree = 0, right_has_empty = 0;
-        struct buffer_head *root_bh, *di_bh = path_root_bh(right_path);
+        struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
-        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
        struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
        struct ocfs2_extent_block *eb;
@@ -2114,7 +2417,7 @@ static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
                 * We have to update i_last_eb_blk during the meta
                 * data delete.
                 */
-                ret = ocfs2_journal_access(handle, inode, di_bh,
+                ret = ocfs2_journal_access(handle, inode, et_root_bh,
                                           OCFS2_JOURNAL_ACCESS_WRITE);
                if (ret) {
                        mlog_errno(ret);
@@ -2189,7 +2492,7 @@ static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
                ocfs2_update_edge_lengths(inode, handle, left_path);
                eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
-                di->i_last_eb_blk = eb->h_blkno;
+                ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
                /*
                 * Removal of the extent in the left leaf was skipped
@@ -2199,7 +2502,7 @@ static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
                if (right_has_empty)
                        ocfs2_remove_empty_extent(left_leaf_el);
-                ret = ocfs2_journal_dirty(handle, di_bh);
+                ret = ocfs2_journal_dirty(handle, et_root_bh);
                if (ret)
                        mlog_errno(ret);
@@ -2322,7 +2625,8 @@ static int __ocfs2_rotate_tree_left(struct inode *inode,
                                    handle_t *handle, int orig_credits,
                                    struct ocfs2_path *path,
                                    struct ocfs2_cached_dealloc_ctxt *dealloc,
-                                    struct ocfs2_path **empty_extent_path)
+                                    struct ocfs2_path **empty_extent_path,
+                                    struct ocfs2_extent_tree *et)
 {
        int ret, subtree_root, deleted;
        u32 right_cpos;
@@ -2395,7 +2699,7 @@ static int __ocfs2_rotate_tree_left(struct inode *inode,
                ret = ocfs2_rotate_subtree_left(inode, handle, left_path,
                                                right_path, subtree_root,
-                                                dealloc, &deleted);
+                                                dealloc, &deleted, et);
                if (ret == -EAGAIN) {
                        /*
                         * The rotation has to temporarily stop due to
@@ -2438,29 +2742,20 @@ out:
 }
 static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle,
-                                       struct ocfs2_path *path,
+                                struct ocfs2_path *path,
-                                       struct ocfs2_cached_dealloc_ctxt *dealloc)
+                                struct ocfs2_cached_dealloc_ctxt *dealloc,
+                                struct ocfs2_extent_tree *et)
 {
        int ret, subtree_index;
        u32 cpos;
        struct ocfs2_path *left_path = NULL;
-        struct ocfs2_dinode *di;
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list *el;
-        /*
-         * XXX: This code assumes that the root is an inode, which is
-         * true for now but may change as tree code gets generic.
-         */
-        di = (struct ocfs2_dinode *)path_root_bh(path)->b_data;
-        if (!OCFS2_IS_VALID_DINODE(di)) {
-                ret = -EIO;
-                ocfs2_error(inode->i_sb,
-                            "Inode %llu has invalid path root",
-                            (unsigned long long)OCFS2_I(inode)->ip_blkno);
-                goto out;
-        }
+        ret = ocfs2_et_sanity_check(inode, et);
+        if (ret)
+                goto out;
        /*
         * There's two ways we handle this depending on
         * whether path is the only existing one.
@@ -2517,7 +2812,7 @@ static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle,
                ocfs2_update_edge_lengths(inode, handle, left_path);
                eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
-                di->i_last_eb_blk = eb->h_blkno;
+                ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
        } else {
                /*
                 * 'path' is also the leftmost path which
@@ -2528,12 +2823,12 @@ static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle,
                 */
                ocfs2_unlink_path(inode, handle, dealloc, path, 1);
-                el = &di->id2.i_list;
+                el = et->et_root_el;
                el->l_tree_depth = 0;
                el->l_next_free_rec = 0;
                memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
-                di->i_last_eb_blk = 0;
+                ocfs2_et_set_last_eb_blk(et, 0);
        }
        ocfs2_journal_dirty(handle, path_root_bh(path));
@@ -2561,7 +2856,8 @@ out:
 */
 static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle,
                                  struct ocfs2_path *path,
-                                  struct ocfs2_cached_dealloc_ctxt *dealloc)
+                                  struct ocfs2_cached_dealloc_ctxt *dealloc,
+                                  struct ocfs2_extent_tree *et)
 {
        int ret, orig_credits = handle->h_buffer_credits;
        struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
@@ -2575,7 +2871,7 @@ static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle,
        if (path->p_tree_depth == 0) {
 rightmost_no_delete:
                /*
-                 * In-inode extents. This is trivially handled, so do
+                 * Inline extents. This is trivially handled, so do
                 * it up front.
                 */
                ret = ocfs2_rotate_rightmost_leaf_left(inode, handle,
@@ -2629,7 +2925,7 @@ rightmost_no_delete:
                 */
                ret = ocfs2_remove_rightmost_path(inode, handle, path,
-                                                  dealloc);
+                                                  dealloc, et);
                if (ret)
                        mlog_errno(ret);
                goto out;
@@ -2641,7 +2937,7 @@ rightmost_no_delete:
         */
 try_rotate:
        ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, path,
-                                       dealloc, &restart_path);
+                                       dealloc, &restart_path, et);
        if (ret && ret != -EAGAIN) {
                mlog_errno(ret);
                goto out;
@@ -2653,7 +2949,7 @@ try_rotate:
                ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits,
                                               tmp_path, dealloc,
-                                               &restart_path);
+                                               &restart_path, et);
                if (ret && ret != -EAGAIN) {
                        mlog_errno(ret);
                        goto out;
@@ -2939,6 +3235,7 @@ static int ocfs2_merge_rec_left(struct inode *inode,
                                handle_t *handle,
                                struct ocfs2_extent_rec *split_rec,
                                struct ocfs2_cached_dealloc_ctxt *dealloc,
+                                struct ocfs2_extent_tree *et,
                                int index)
 {
        int ret, i, subtree_index = 0, has_empty_extent = 0;
@@ -3059,7 +3356,8 @@ static int ocfs2_merge_rec_left(struct inode *inode,
                    le16_to_cpu(el->l_next_free_rec) == 1) {
                        ret = ocfs2_remove_rightmost_path(inode, handle,
-                                                          right_path, dealloc);
+                                                          right_path,
+                                                          dealloc, et);
                        if (ret) {
                                mlog_errno(ret);
                                goto out;
@@ -3086,7 +3384,8 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                                     int split_index,
                                     struct ocfs2_extent_rec *split_rec,
                                     struct ocfs2_cached_dealloc_ctxt *dealloc,
-                                     struct ocfs2_merge_ctxt *ctxt)
+                                     struct ocfs2_merge_ctxt *ctxt,
+                                     struct ocfs2_extent_tree *et)
 {
        int ret = 0;
@@ -3104,7 +3403,7 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                 * illegal.
                 */
                ret = ocfs2_rotate_tree_left(inode, handle, path,
-                                             dealloc);
+                                             dealloc, et);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -3147,7 +3446,8 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
                /* The merge left us with an empty extent, remove it. */
-                ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
+                ret = ocfs2_rotate_tree_left(inode, handle, path,
+                                             dealloc, et);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -3161,7 +3461,7 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                 */
                ret = ocfs2_merge_rec_left(inode, path,
                                           handle, rec,
-                                           dealloc,
+                                           dealloc, et,
                                           split_index);
                if (ret) {
@@ -3170,7 +3470,7 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                }
                ret = ocfs2_rotate_tree_left(inode, handle, path,
-                                             dealloc);
+                                             dealloc, et);
                /*
                 * Error from this last rotate is not critical, so
                 * print but don't bubble it up.
@@ -3190,7 +3490,7 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                        ret = ocfs2_merge_rec_left(inode,
                                                   path,
                                                   handle, split_rec,
-                                                   dealloc,
+                                                   dealloc, et,
                                                   split_index);
                        if (ret) {
                                mlog_errno(ret);
@@ -3213,7 +3513,7 @@ static int ocfs2_try_to_merge_extent(struct inode *inode,
                         * our leaf. Try to rotate it away.
                         */
                        ret = ocfs2_rotate_tree_left(inode, handle, path,
-                                                     dealloc);
+                                                     dealloc, et);
                        if (ret)
                                mlog_errno(ret);
                        ret = 0;
@@ -3347,16 +3647,6 @@ rotate:
        ocfs2_rotate_leaf(el, insert_rec);
 }
-static inline void ocfs2_update_dinode_clusters(struct inode *inode,
-                                                struct ocfs2_dinode *di,
-                                                u32 clusters)
-{
-        le32_add_cpu(&di->i_clusters, clusters);
-        spin_lock(&OCFS2_I(inode)->ip_lock);
-        OCFS2_I(inode)->ip_clusters = le32_to_cpu(di->i_clusters);
-        spin_unlock(&OCFS2_I(inode)->ip_lock);
-}
 static void ocfs2_adjust_rightmost_records(struct inode *inode,
                                           handle_t *handle,
                                           struct ocfs2_path *path,
@@ -3558,8 +3848,8 @@ static void ocfs2_split_record(struct inode *inode,
 }
 /*
- * This function only does inserts on an allocation b-tree. For dinode
+ * This function only does inserts on an allocation b-tree. For tree
- * lists, ocfs2_insert_at_leaf() is called directly.
+ * depth = 0, ocfs2_insert_at_leaf() is called directly.
 *
 * right_path is the path we want to do the actual insert
 * in. left_path should only be passed in if we need to update that
@@ -3656,7 +3946,7 @@ out:
 static int ocfs2_do_insert_extent(struct inode *inode,
                                  handle_t *handle,
-                                  struct buffer_head *di_bh,
+                                  struct ocfs2_extent_tree *et,
                                  struct ocfs2_extent_rec *insert_rec,
                                  struct ocfs2_insert_type *type)
 {
@@ -3664,13 +3954,11 @@ static int ocfs2_do_insert_extent(struct inode *inode,
        u32 cpos;
        struct ocfs2_path *right_path = NULL;
        struct ocfs2_path *left_path = NULL;
-        struct ocfs2_dinode *di;
        struct ocfs2_extent_list *el;
-        di = (struct ocfs2_dinode *) di_bh->b_data;
+        el = et->et_root_el;
-        el = &di->id2.i_list;
-        ret = ocfs2_journal_access(handle, inode, di_bh,
+        ret = ocfs2_journal_access(handle, inode, et->et_root_bh,
                                   OCFS2_JOURNAL_ACCESS_WRITE);
        if (ret) {
                mlog_errno(ret);
@@ -3682,7 +3970,7 @@ static int ocfs2_do_insert_extent(struct inode *inode,
                goto out_update_clusters;
        }
-        right_path = ocfs2_new_inode_path(di_bh);
+        right_path = ocfs2_new_path(et->et_root_bh, et->et_root_el);
        if (!right_path) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -3732,7 +4020,7 @@ static int ocfs2_do_insert_extent(struct inode *inode,
                 * ocfs2_rotate_tree_right() might have extended the
                 * transaction without re-journaling our tree root.
                 */
-                ret = ocfs2_journal_access(handle, inode, di_bh,
+                ret = ocfs2_journal_access(handle, inode, et->et_root_bh,
                                           OCFS2_JOURNAL_ACCESS_WRITE);
                if (ret) {
                        mlog_errno(ret);
@@ -3757,10 +4045,10 @@ static int ocfs2_do_insert_extent(struct inode *inode,
 out_update_clusters:
        if (type->ins_split == SPLIT_NONE)
-                ocfs2_update_dinode_clusters(inode, di,
+                ocfs2_et_update_clusters(inode, et,
-                                             le16_to_cpu(insert_rec->e_leaf_clusters));
+                                         le16_to_cpu(insert_rec->e_leaf_clusters));
-        ret = ocfs2_journal_dirty(handle, di_bh);
+        ret = ocfs2_journal_dirty(handle, et->et_root_bh);
        if (ret)
                mlog_errno(ret);
@@ -3890,7 +4178,8 @@ out:
 static void ocfs2_figure_contig_type(struct inode *inode,
                                     struct ocfs2_insert_type *insert,
                                     struct ocfs2_extent_list *el,
-                                     struct ocfs2_extent_rec *insert_rec)
+                                     struct ocfs2_extent_rec *insert_rec,
+                                     struct ocfs2_extent_tree *et)
 {
        int i;
        enum ocfs2_contig_type contig_type = CONTIG_NONE;
@@ -3906,6 +4195,21 @@ static void ocfs2_figure_contig_type(struct inode *inode,
                }
        }
        insert->ins_contig = contig_type;
+        if (insert->ins_contig != CONTIG_NONE) {
+                struct ocfs2_extent_rec *rec =
+                                &el->l_recs[insert->ins_contig_index];
+                unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
+                                   le16_to_cpu(insert_rec->e_leaf_clusters);
+                /*
+                 * Caller might want us to limit the size of extents, don't
+                 * calculate contiguousness if we might exceed that limit.
+                 */
+                if (et->et_max_leaf_clusters &&
+                    (len > et->et_max_leaf_clusters))
+                        insert->ins_contig = CONTIG_NONE;
+        }
 }
 /*
@@ -3914,8 +4218,8 @@ static void ocfs2_figure_contig_type(struct inode *inode,
 * ocfs2_figure_appending_type() will figure out whether we'll have to
 * insert at the tail of the rightmost leaf.
 *
- * This should also work against the dinode list for tree's with 0
+ * This should also work against the root extent list for tree's with 0
- * depth. If we consider the dinode list to be the rightmost leaf node
+ * depth. If we consider the root extent list to be the rightmost leaf node
 * then the logic here makes sense.
 */
 static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
@@ -3966,14 +4270,13 @@ set_tail_append:
 * structure.
 */
 static int ocfs2_figure_insert_type(struct inode *inode,
-                                    struct buffer_head *di_bh,
+                                    struct ocfs2_extent_tree *et,
                                    struct buffer_head **last_eb_bh,
                                    struct ocfs2_extent_rec *insert_rec,
                                    int *free_records,
                                    struct ocfs2_insert_type *insert)
 {
        int ret;
-        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list *el;
        struct ocfs2_path *path = NULL;
@@ -3981,7 +4284,7 @@ static int ocfs2_figure_insert_type(struct inode *inode,
        insert->ins_split = SPLIT_NONE;
-        el = &di->id2.i_list;
+        el = et->et_root_el;
        insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
        if (el->l_tree_depth) {
@@ -3991,9 +4294,7 @@ static int ocfs2_figure_insert_type(struct inode *inode,
                 * ocfs2_figure_insert_type() and ocfs2_add_branch()
                 * may want it later.
                 */
-                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                ret = ocfs2_read_block(inode, ocfs2_et_get_last_eb_blk(et), &bh);
-                                       le64_to_cpu(di->i_last_eb_blk), &bh,
-                                       OCFS2_BH_CACHED, inode);
                if (ret) {
                        mlog_exit(ret);
                        goto out;
@@ -4014,12 +4315,12 @@ static int ocfs2_figure_insert_type(struct inode *inode,
                le16_to_cpu(el->l_next_free_rec);
        if (!insert->ins_tree_depth) {
-                ocfs2_figure_contig_type(inode, insert, el, insert_rec);
+                ocfs2_figure_contig_type(inode, insert, el, insert_rec, et);
                ocfs2_figure_appending_type(insert, el, insert_rec);
                return 0;
        }
-        path = ocfs2_new_inode_path(di_bh);
+        path = ocfs2_new_path(et->et_root_bh, et->et_root_el);
        if (!path) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -4048,7 +4349,7 @@ static int ocfs2_figure_insert_type(struct inode *inode,
         *     into two types of appends: simple record append, or a
         *     rotate inside the tail leaf.
         */
-        ocfs2_figure_contig_type(inode, insert, el, insert_rec);
+        ocfs2_figure_contig_type(inode, insert, el, insert_rec, et);
        /*
         * The insert code isn't quite ready to deal with all cases of
@@ -4069,7 +4370,8 @@ static int ocfs2_figure_insert_type(struct inode *inode,
         * the case that we're doing a tail append, so maybe we can
         * take advantage of that information somehow.
         */
-        if (le64_to_cpu(di->i_last_eb_blk) == path_leaf_bh(path)->b_blocknr) {
+        if (ocfs2_et_get_last_eb_blk(et) ==
+            path_leaf_bh(path)->b_blocknr) {
                /*
                 * Ok, ocfs2_find_path() returned us the rightmost
                 * tree path. This might be an appending insert. There are
@@ -4099,7 +4401,7 @@ out:
 int ocfs2_insert_extent(struct ocfs2_super *osb,
                        handle_t *handle,
                        struct inode *inode,
-                        struct buffer_head *fe_bh,
+                        struct ocfs2_extent_tree *et,
                        u32 cpos,
                        u64 start_blk,
                        u32 new_clusters,
@@ -4112,26 +4414,21 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
        struct ocfs2_insert_type insert = {0, };
        struct ocfs2_extent_rec rec;
-        BUG_ON(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL);
        mlog(0, "add %u clusters at position %u to inode %llu\n",
             new_clusters, cpos, (unsigned long long)OCFS2_I(inode)->ip_blkno);
-        mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
-                        (OCFS2_I(inode)->ip_clusters != cpos),
-                        "Device %s, asking for sparse allocation: inode %llu, "
-                        "cpos %u, clusters %u\n",
-                        osb->dev_str,
-                        (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos,
-                        OCFS2_I(inode)->ip_clusters);
        memset(&rec, 0, sizeof(rec));
        rec.e_cpos = cpu_to_le32(cpos);
        rec.e_blkno = cpu_to_le64(start_blk);
        rec.e_leaf_clusters = cpu_to_le16(new_clusters);
        rec.e_flags = flags;
+        status = ocfs2_et_insert_check(inode, et, &rec);
+        if (status) {
+                mlog_errno(status);
+                goto bail;
+        }
-        status = ocfs2_figure_insert_type(inode, fe_bh, &last_eb_bh, &rec,
+        status = ocfs2_figure_insert_type(inode, et, &last_eb_bh, &rec,
                                          &free_records, &insert);
        if (status < 0) {
                mlog_errno(status);
@@ -4145,7 +4442,7 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
             free_records, insert.ins_tree_depth);
        if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
-                status = ocfs2_grow_tree(inode, handle, fe_bh,
+                status = ocfs2_grow_tree(inode, handle, et,
                                         &insert.ins_tree_depth, &last_eb_bh,
                                         meta_ac);
                if (status) {
@@ -4155,17 +4452,124 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
        }
        /* Finally, we can add clusters. This might rotate the tree for us. */
-        status = ocfs2_do_insert_extent(inode, handle, fe_bh, &rec, &insert);
+        status = ocfs2_do_insert_extent(inode, handle, et, &rec, &insert);
        if (status < 0)
                mlog_errno(status);
-        else
+        else if (et->et_ops == &ocfs2_dinode_et_ops)
                ocfs2_extent_map_insert_rec(inode, &rec);
 bail:
-        if (last_eb_bh)
+        brelse(last_eb_bh);
-                brelse(last_eb_bh);
+        mlog_exit(status);
+        return status;
+}
+/*
+ * Allcate and add clusters into the extent b-tree.
+ * The new clusters(clusters_to_add) will be inserted at logical_offset.
+ * The extent b-tree's root is specified by et, and
+ * it is not limited to the file storage. Any extent tree can use this
+ * function if it implements the proper ocfs2_extent_tree.
+ */
+int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
+                                struct inode *inode,
+                                u32 *logical_offset,
+                                u32 clusters_to_add,
+                                int mark_unwritten,
+                                struct ocfs2_extent_tree *et,
+                                handle_t *handle,
+                                struct ocfs2_alloc_context *data_ac,
+                                struct ocfs2_alloc_context *meta_ac,
+                                enum ocfs2_alloc_restarted *reason_ret)
+{
+        int status = 0;
+        int free_extents;
+        enum ocfs2_alloc_restarted reason = RESTART_NONE;
+        u32 bit_off, num_bits;
+        u64 block;
+        u8 flags = 0;
+        BUG_ON(!clusters_to_add);
+        if (mark_unwritten)
+                flags = OCFS2_EXT_UNWRITTEN;
+        free_extents = ocfs2_num_free_extents(osb, inode, et);
+        if (free_extents < 0) {
+                status = free_extents;
+                mlog_errno(status);
+                goto leave;
+        }
+        /* there are two cases which could cause us to EAGAIN in the
+         * we-need-more-metadata case:
+         * 1) we haven't reserved *any*
+         * 2) we are so fragmented, we've needed to add metadata too
+         *    many times. */
+        if (!free_extents && !meta_ac) {
+                mlog(0, "we haven't reserved any metadata!\n");
+                status = -EAGAIN;
+                reason = RESTART_META;
+                goto leave;
+        } else if ((!free_extents)
+                   && (ocfs2_alloc_context_bits_left(meta_ac)
+                       < ocfs2_extend_meta_needed(et->et_root_el))) {
+                mlog(0, "filesystem is really fragmented...\n");
+                status = -EAGAIN;
+                reason = RESTART_META;
+                goto leave;
+        }
+        status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
+                                        clusters_to_add, &bit_off, &num_bits);
+        if (status < 0) {
+                if (status != -ENOSPC)
+                        mlog_errno(status);
+                goto leave;
+        }
+        BUG_ON(num_bits > clusters_to_add);
+        /* reserve our write early -- insert_extent may update the inode */
+        status = ocfs2_journal_access(handle, inode, et->et_root_bh,
+                                      OCFS2_JOURNAL_ACCESS_WRITE);
+        if (status < 0) {
+                mlog_errno(status);
+                goto leave;
+        }
+        block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
+        mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
+             num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
+        status = ocfs2_insert_extent(osb, handle, inode, et,
+                                     *logical_offset, block,
+                                     num_bits, flags, meta_ac);
+        if (status < 0) {
+                mlog_errno(status);
+                goto leave;
+        }
+        status = ocfs2_journal_dirty(handle, et->et_root_bh);
+        if (status < 0) {
+                mlog_errno(status);
+                goto leave;
+        }
+        clusters_to_add -= num_bits;
+        *logical_offset += num_bits;
+        if (clusters_to_add) {
+                mlog(0, "need to alloc once more, wanted = %u\n",
+                     clusters_to_add);
+                status = -EAGAIN;
+                reason = RESTART_TRANS;
+        }
+leave:
        mlog_exit(status);
+        if (reason_ret)
+                *reason_ret = reason;
        return status;
 }
@@ -4192,7 +4596,7 @@ static void ocfs2_make_right_split_rec(struct super_block *sb,
 static int ocfs2_split_and_insert(struct inode *inode,
                                  handle_t *handle,
                                  struct ocfs2_path *path,
-                                  struct buffer_head *di_bh,
+                                  struct ocfs2_extent_tree *et,
                                  struct buffer_head **last_eb_bh,
                                  int split_index,
                                  struct ocfs2_extent_rec *orig_split_rec,
@@ -4206,7 +4610,6 @@ static int ocfs2_split_and_insert(struct inode *inode,
        struct ocfs2_extent_rec split_rec = *orig_split_rec;
        struct ocfs2_insert_type insert;
        struct ocfs2_extent_block *eb;
-        struct ocfs2_dinode *di;
 leftright:
        /*
@@ -4215,8 +4618,7 @@ leftright:
         */
        rec = path_leaf_el(path)->l_recs[split_index];
-        di = (struct ocfs2_dinode *)di_bh->b_data;
+        rightmost_el = et->et_root_el;
-        rightmost_el = &di->id2.i_list;
        depth = le16_to_cpu(rightmost_el->l_tree_depth);
        if (depth) {
@@ -4227,8 +4629,8 @@ leftright:
        if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
            le16_to_cpu(rightmost_el->l_count)) {
-                ret = ocfs2_grow_tree(inode, handle, di_bh, &depth, last_eb_bh,
+                ret = ocfs2_grow_tree(inode, handle, et,
-                                      meta_ac);
+                                      &depth, last_eb_bh, meta_ac);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -4265,8 +4667,7 @@ leftright:
                do_leftright = 1;
        }
-        ret = ocfs2_do_insert_extent(inode, handle, di_bh, &split_rec,
+        ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert);
-                                     &insert);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -4308,8 +4709,9 @@ out:
 * of the tree is required. All other cases will degrade into a less
 * optimal tree layout.
 *
- * last_eb_bh should be the rightmost leaf block for any inode with a
+ * last_eb_bh should be the rightmost leaf block for any extent
- * btree. Since a split may grow the tree or a merge might shrink it, the caller cannot trust the contents of that buffer after this call.
+ * btree. Since a split may grow the tree or a merge might shrink it,
+ * the caller cannot trust the contents of that buffer after this call.
 *
 * This code is optimized for readability - several passes might be
 * made over certain portions of the tree. All of those blocks will
@@ -4317,7 +4719,7 @@ out:
 * extra overhead is not expressed in terms of disk reads.
 */
 static int __ocfs2_mark_extent_written(struct inode *inode,
-                                       struct buffer_head *di_bh,
+                                       struct ocfs2_extent_tree *et,
                                       handle_t *handle,
                                       struct ocfs2_path *path,
                                       int split_index,
@@ -4357,11 +4759,9 @@ static int __ocfs2_mark_extent_written(struct inode *inode,
         */
        if (path->p_tree_depth) {
                struct ocfs2_extent_block *eb;
-                struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
-                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                ret = ocfs2_read_block(inode, ocfs2_et_get_last_eb_blk(et),
-                                       le64_to_cpu(di->i_last_eb_blk),
+                                       &last_eb_bh);
-                                       &last_eb_bh, OCFS2_BH_CACHED, inode);
                if (ret) {
                        mlog_exit(ret);
                        goto out;
@@ -4394,7 +4794,7 @@ static int __ocfs2_mark_extent_written(struct inode *inode,
                if (ctxt.c_split_covers_rec)
                        el->l_recs[split_index] = *split_rec;
                else
-                        ret = ocfs2_split_and_insert(inode, handle, path, di_bh,
+                        ret = ocfs2_split_and_insert(inode, handle, path, et,
                                                     &last_eb_bh, split_index,
                                                     split_rec, meta_ac);
                if (ret)
@@ -4402,7 +4802,7 @@ static int __ocfs2_mark_extent_written(struct inode *inode,
        } else {
                ret = ocfs2_try_to_merge_extent(inode, handle, path,
                                                split_index, split_rec,
-                                                dealloc, &ctxt);
+                                                dealloc, &ctxt, et);
                if (ret)
                        mlog_errno(ret);
        }
@@ -4420,7 +4820,8 @@ out:
 *
 * The caller is responsible for passing down meta_ac if we'll need it.
 */
-int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
+int ocfs2_mark_extent_written(struct inode *inode,
+                              struct ocfs2_extent_tree *et,
                              handle_t *handle, u32 cpos, u32 len, u32 phys,
                              struct ocfs2_alloc_context *meta_ac,
                              struct ocfs2_cached_dealloc_ctxt *dealloc)
@@ -4446,10 +4847,14 @@ int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
        /*
         * XXX: This should be fixed up so that we just re-insert the
         * next extent records.
+         *
+         * XXX: This is a hack on the extent tree, maybe it should be
+         * an op?
         */
-        ocfs2_extent_map_trunc(inode, 0);
+        if (et->et_ops == &ocfs2_dinode_et_ops)
+                ocfs2_extent_map_trunc(inode, 0);
-        left_path = ocfs2_new_inode_path(di_bh);
+        left_path = ocfs2_new_path(et->et_root_bh, et->et_root_el);
        if (!left_path) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -4480,8 +4885,9 @@ int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
        split_rec.e_flags = path_leaf_el(left_path)->l_recs[index].e_flags;
        split_rec.e_flags &= ~OCFS2_EXT_UNWRITTEN;
-        ret = __ocfs2_mark_extent_written(inode, di_bh, handle, left_path,
+        ret = __ocfs2_mark_extent_written(inode, et, handle, left_path,
-                                          index, &split_rec, meta_ac, dealloc);
+                                          index, &split_rec, meta_ac,
+                                          dealloc);
        if (ret)
                mlog_errno(ret);
@@ -4490,13 +4896,12 @@ out:
        return ret;
 }
-static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
+static int ocfs2_split_tree(struct inode *inode, struct ocfs2_extent_tree *et,
                            handle_t *handle, struct ocfs2_path *path,
                            int index, u32 new_range,
                            struct ocfs2_alloc_context *meta_ac)
 {
        int ret, depth, credits = handle->h_buffer_credits;
-        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
        struct buffer_head *last_eb_bh = NULL;
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list *rightmost_el, *el;
@@ -4513,9 +4918,8 @@ static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
        depth = path->p_tree_depth;
        if (depth > 0) {
-                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                ret = ocfs2_read_block(inode, ocfs2_et_get_last_eb_blk(et),
-                                       le64_to_cpu(di->i_last_eb_blk),
+                                       &last_eb_bh);
-                                       &last_eb_bh, OCFS2_BH_CACHED, inode);
                if (ret < 0) {
                        mlog_errno(ret);
                        goto out;
@@ -4526,7 +4930,8 @@ static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
        } else
                rightmost_el = path_leaf_el(path);
-        credits += path->p_tree_depth + ocfs2_extend_meta_needed(di);
+        credits += path->p_tree_depth +
+                   ocfs2_extend_meta_needed(et->et_root_el);
        ret = ocfs2_extend_trans(handle, credits);
        if (ret) {
                mlog_errno(ret);
@@ -4535,7 +4940,7 @@ static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
        if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
            le16_to_cpu(rightmost_el->l_count)) {
-                ret = ocfs2_grow_tree(inode, handle, di_bh, &depth, &last_eb_bh,
+                ret = ocfs2_grow_tree(inode, handle, et, &depth, &last_eb_bh,
                                      meta_ac);
                if (ret) {
                        mlog_errno(ret);
@@ -4549,7 +4954,7 @@ static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
        insert.ins_split = SPLIT_RIGHT;
        insert.ins_tree_depth = depth;
-        ret = ocfs2_do_insert_extent(inode, handle, di_bh, &split_rec, &insert);
+        ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert);
        if (ret)
                mlog_errno(ret);
@@ -4561,7 +4966,8 @@ out:
 static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle,
                              struct ocfs2_path *path, int index,
                              struct ocfs2_cached_dealloc_ctxt *dealloc,
-                              u32 cpos, u32 len)
+                              u32 cpos, u32 len,
+                              struct ocfs2_extent_tree *et)
 {
        int ret;
        u32 left_cpos, rec_range, trunc_range;
@@ -4573,7 +4979,7 @@ static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle,
        struct ocfs2_extent_block *eb;
        if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
-                ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
+                ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -4704,7 +5110,7 @@ static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle,
        ocfs2_journal_dirty(handle, path_leaf_bh(path));
-        ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
+        ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -4715,7 +5121,8 @@ out:
        return ret;
 }
-int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
+int ocfs2_remove_extent(struct inode *inode,
+                        struct ocfs2_extent_tree *et,
                        u32 cpos, u32 len, handle_t *handle,
                        struct ocfs2_alloc_context *meta_ac,
                        struct ocfs2_cached_dealloc_ctxt *dealloc)
@@ -4724,11 +5131,11 @@ int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
        u32 rec_range, trunc_range;
        struct ocfs2_extent_rec *rec;
        struct ocfs2_extent_list *el;
-        struct ocfs2_path *path;
+        struct ocfs2_path *path = NULL;
        ocfs2_extent_map_trunc(inode, 0);
-        path = ocfs2_new_inode_path(di_bh);
+        path = ocfs2_new_path(et->et_root_bh, et->et_root_el);
        if (!path) {
                ret = -ENOMEM;
                mlog_errno(ret);
@@ -4781,13 +5188,13 @@ int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
        if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
                ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
-                                         cpos, len);
+                                         cpos, len, et);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
        } else {
-                ret = ocfs2_split_tree(inode, di_bh, handle, path, index,
+                ret = ocfs2_split_tree(inode, et, handle, path, index,
                                       trunc_range, meta_ac);
                if (ret) {
                        mlog_errno(ret);
@@ -4836,7 +5243,7 @@ int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
                }
                ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
-                                         cpos, len);
+                                         cpos, len, et);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -5179,8 +5586,7 @@ static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
                goto bail;
        }
-        status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
+        status = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, &bh);
-                                  OCFS2_BH_CACHED, inode);
        if (status < 0) {
                iput(inode);
                mlog_errno(status);
@@ -5255,8 +5661,7 @@ int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
 bail:
        if (tl_inode)
                iput(tl_inode);
-        if (tl_bh)
+        brelse(tl_bh);
-                brelse(tl_bh);
        if (status < 0 && (*tl_copy)) {
                kfree(*tl_copy);
@@ -5999,20 +6404,13 @@ bail:
        return status;
 }
-static int ocfs2_writeback_zero_func(handle_t *handle, struct buffer_head *bh)
+static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
 {
        set_buffer_uptodate(bh);
        mark_buffer_dirty(bh);
        return 0;
 }
-static int ocfs2_ordered_zero_func(handle_t *handle, struct buffer_head *bh)
-{
-        set_buffer_uptodate(bh);
-        mark_buffer_dirty(bh);
-        return ocfs2_journal_dirty_data(handle, bh);
-}
 static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
                                     unsigned int from, unsigned int to,
                                     struct page *page, int zero, u64 *phys)
@@ -6031,17 +6429,18 @@ static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
         * here if they aren't - ocfs2_map_page_blocks()
         * might've skipped some
         */
-        if (ocfs2_should_order_data(inode)) {
+        ret = walk_page_buffers(handle, page_buffers(page),
-                ret = walk_page_buffers(handle,
+                                from, to, &partial,
-                                        page_buffers(page),
+                                ocfs2_zero_func);
-                                        from, to, &partial,
+        if (ret < 0)
-                                        ocfs2_ordered_zero_func);
+                mlog_errno(ret);
-                if (ret < 0)
+        else if (ocfs2_should_order_data(inode)) {
-                        mlog_errno(ret);
+                ret = ocfs2_jbd2_file_inode(handle, inode);
-        } else {
+#ifdef CONFIG_OCFS2_COMPAT_JBD
                ret = walk_page_buffers(handle, page_buffers(page),
                                        from, to, &partial,
-                                        ocfs2_writeback_zero_func);
+                                        ocfs2_journal_dirty_data);
+#endif
                if (ret < 0)
                        mlog_errno(ret);
        }
@@ -6206,20 +6605,29 @@ out:
        return ret;
 }
-static void ocfs2_zero_dinode_id2(struct inode *inode, struct ocfs2_dinode *di)
+static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
+                                             struct ocfs2_dinode *di)
 {
        unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
+        unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
-        memset(&di->id2, 0, blocksize - offsetof(struct ocfs2_dinode, id2));
+        if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
+                memset(&di->id2, 0, blocksize -
+                                    offsetof(struct ocfs2_dinode, id2) -
+                                    xattrsize);
+        else
+                memset(&di->id2, 0, blocksize -
+                                    offsetof(struct ocfs2_dinode, id2));
 }
 void ocfs2_dinode_new_extent_list(struct inode *inode,
                                  struct ocfs2_dinode *di)
 {
-        ocfs2_zero_dinode_id2(inode, di);
+        ocfs2_zero_dinode_id2_with_xattr(inode, di);
        di->id2.i_list.l_tree_depth = 0;
        di->id2.i_list.l_next_free_rec = 0;
-        di->id2.i_list.l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(inode->i_sb));
+        di->id2.i_list.l_count = cpu_to_le16(
+                ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
 }
 void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
@@ -6236,9 +6644,10 @@ void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
         * We clear the entire i_data structure here so that all
         * fields can be properly initialized.
         */
-        ocfs2_zero_dinode_id2(inode, di);
+        ocfs2_zero_dinode_id2_with_xattr(inode, di);
-        idata->id_count = cpu_to_le16(ocfs2_max_inline_data(inode->i_sb));
+        idata->id_count = cpu_to_le16(
+                        ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
 }
 int ocfs2_convert_inline_data_to_extents(struct inode *inode,
@@ -6253,6 +6662,7 @@ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
        struct ocfs2_alloc_context *data_ac = NULL;
        struct page **pages = NULL;
        loff_t end = osb->s_clustersize;
+        struct ocfs2_extent_tree et;
        has_data = i_size_read(inode) ? 1 : 0;
@@ -6352,7 +6762,8 @@ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
                 * this proves to be false, we could always re-build
                 * the in-inode data from our pages.
                 */
-                ret = ocfs2_insert_extent(osb, handle, inode, di_bh,
+                ocfs2_init_dinode_extent_tree(&et, inode, di_bh);
+                ret = ocfs2_insert_extent(osb, handle, inode, &et,
                                          0, block, 1, 0, NULL);
                if (ret) {
                        mlog_errno(ret);
@@ -6395,13 +6806,14 @@ int ocfs2_commit_truncate(struct ocfs2_super *osb,
        handle_t *handle = NULL;
        struct inode *tl_inode = osb->osb_tl_inode;
        struct ocfs2_path *path = NULL;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
        mlog_entry_void();
        new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
                                                     i_size_read(inode));
-        path = ocfs2_new_inode_path(fe_bh);
+        path = ocfs2_new_path(fe_bh, &di->id2.i_list);
        if (!path) {
                status = -ENOMEM;
                mlog_errno(status);
@@ -6572,8 +6984,8 @@ int ocfs2_prepare_truncate(struct ocfs2_super *osb,
        ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc);
        if (fe->id2.i_list.l_tree_depth) {
-                status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
+                status = ocfs2_read_block(inode, le64_to_cpu(fe->i_last_eb_blk),
-                                          &last_eb_bh, OCFS2_BH_CACHED, inode);
+                                          &last_eb_bh);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
@@ -6686,8 +7098,7 @@ static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc)
                mlog(ML_NOTICE,
                     "Truncate completion has non-empty dealloc context\n");
-        if (tc->tc_last_eb_bh)
+        brelse(tc->tc_last_eb_bh);
-                brelse(tc->tc_last_eb_bh);
        kfree(tc);
 }
diff --git a/fs/ocfs2/alloc.h b/fs/ocfs2/alloc.h
index 60cd3d59230c..70257c84cfbe 100644
--- a/fs/ocfs2/alloc.h
+++ b/fs/ocfs2/alloc.h
@@ -26,30 +26,102 @@
 #ifndef OCFS2_ALLOC_H
 #define OCFS2_ALLOC_H
+/*
+ * For xattr tree leaf, we limit the leaf byte size to be 64K.
+ */
+#define OCFS2_MAX_XATTR_TREE_LEAF_SIZE 65536
+/*
+ * ocfs2_extent_tree and ocfs2_extent_tree_operations are used to abstract
+ * the b-tree operations in ocfs2. Now all the b-tree operations are not
+ * limited to ocfs2_dinode only. Any data which need to allocate clusters
+ * to store can use b-tree. And it only needs to implement its ocfs2_extent_tree
+ * and operation.
+ *
+ * ocfs2_extent_tree becomes the first-class object for extent tree
+ * manipulation.  Callers of the alloc.c code need to fill it via one of
+ * the ocfs2_init_*_extent_tree() operations below.
+ *
+ * ocfs2_extent_tree contains info for the root of the b-tree, it must have a
+ * root ocfs2_extent_list and a root_bh so that they can be used in the b-tree
+ * functions.
+ * ocfs2_extent_tree_operations abstract the normal operations we do for
+ * the root of extent b-tree.
+ */
+struct ocfs2_extent_tree_operations;
+struct ocfs2_extent_tree {
+        struct ocfs2_extent_tree_operations     *et_ops;
+        struct buffer_head                      *et_root_bh;
+        struct ocfs2_extent_list                *et_root_el;
+        void                                    *et_object;
+        unsigned int                            et_max_leaf_clusters;
+};
+/*
+ * ocfs2_init_*_extent_tree() will fill an ocfs2_extent_tree from the
+ * specified object buffer.
+ */
+void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
+                                   struct inode *inode,
+                                   struct buffer_head *bh);
+void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
+                                       struct inode *inode,
+                                       struct buffer_head *bh);
+void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
+                                        struct inode *inode,
+                                        struct buffer_head *bh,
+                                        struct ocfs2_xattr_value_root *xv);
 struct ocfs2_alloc_context;
 int ocfs2_insert_extent(struct ocfs2_super *osb,
                        handle_t *handle,
                        struct inode *inode,
-                        struct buffer_head *fe_bh,
+                        struct ocfs2_extent_tree *et,
                        u32 cpos,
                        u64 start_blk,
                        u32 new_clusters,
                        u8 flags,
                        struct ocfs2_alloc_context *meta_ac);
+enum ocfs2_alloc_restarted {
+        RESTART_NONE = 0,
+        RESTART_TRANS,
+        RESTART_META
+};
+int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
+                                struct inode *inode,
+                                u32 *logical_offset,
+                                u32 clusters_to_add,
+                                int mark_unwritten,
+                                struct ocfs2_extent_tree *et,
+                                handle_t *handle,
+                                struct ocfs2_alloc_context *data_ac,
+                                struct ocfs2_alloc_context *meta_ac,
+                                enum ocfs2_alloc_restarted *reason_ret);
 struct ocfs2_cached_dealloc_ctxt;
-int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
+int ocfs2_mark_extent_written(struct inode *inode,
+                              struct ocfs2_extent_tree *et,
                              handle_t *handle, u32 cpos, u32 len, u32 phys,
                              struct ocfs2_alloc_context *meta_ac,
                              struct ocfs2_cached_dealloc_ctxt *dealloc);
-int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
+int ocfs2_remove_extent(struct inode *inode,
+                        struct ocfs2_extent_tree *et,
                        u32 cpos, u32 len, handle_t *handle,
                        struct ocfs2_alloc_context *meta_ac,
                        struct ocfs2_cached_dealloc_ctxt *dealloc);
 int ocfs2_num_free_extents(struct ocfs2_super *osb,
                           struct inode *inode,
-                           struct ocfs2_dinode *fe);
+                           struct ocfs2_extent_tree *et);
-/* how many new metadata chunks would an allocation need at maximum? */
-static inline int ocfs2_extend_meta_needed(struct ocfs2_dinode *fe)
+/*
+ * how many new metadata chunks would an allocation need at maximum?
+ *
+ * Please note that the caller must make sure that root_el is the root
+ * of extent tree. So for an inode, it should be &fe->id2.i_list. Otherwise
+ * the result may be wrong.
+ */
+static inline int ocfs2_extend_meta_needed(struct ocfs2_extent_list *root_el)
 {
        /*
         * Rather than do all the work of determining how much we need
@@ -59,7 +131,7 @@ static inline int ocfs2_extend_meta_needed(struct ocfs2_dinode *fe)
         * new tree_depth==0 extent_block, and one block at the new
         * top-of-the tree.
         */
-        return le16_to_cpu(fe->id2.i_list.l_tree_depth) + 2;
+        return le16_to_cpu(root_el->l_tree_depth) + 2;
 }
 void ocfs2_dinode_new_extent_list(struct inode *inode, struct ocfs2_dinode *di);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index a53da1466277..c22543b33420 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -68,9 +68,7 @@ static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
                goto bail;
        }
-        status = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+        status = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, &bh);
-                                  OCFS2_I(inode)->ip_blkno,
-                                  &bh, OCFS2_BH_CACHED, inode);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -128,8 +126,7 @@ static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
        err = 0;
 bail:
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(err);
        return err;
@@ -261,13 +258,11 @@ static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
 {
        int ret;
        struct buffer_head *di_bh = NULL;
-        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        BUG_ON(!PageLocked(page));
        BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
-        ret = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &di_bh,
+        ret = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, &di_bh);
-                               OCFS2_BH_CACHED, inode);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -485,11 +480,14 @@ handle_t *ocfs2_start_walk_page_trans(struct inode *inode,
        }
        if (ocfs2_should_order_data(inode)) {
+                ret = ocfs2_jbd2_file_inode(handle, inode);
+#ifdef CONFIG_OCFS2_COMPAT_JBD
                ret = walk_page_buffers(handle,
                                        page_buffers(page),
                                        from, to, NULL,
                                        ocfs2_journal_dirty_data);
-                if (ret < 0) 
+#endif
+                if (ret < 0)
                        mlog_errno(ret);
        }
 out:
@@ -669,7 +667,7 @@ static void ocfs2_invalidatepage(struct page *page, unsigned long offset)
 {
        journal_t *journal = OCFS2_SB(page->mapping->host->i_sb)->journal->j_journal;
-        journal_invalidatepage(journal, page, offset);
+        jbd2_journal_invalidatepage(journal, page, offset);
 }
 static int ocfs2_releasepage(struct page *page, gfp_t wait)
@@ -678,7 +676,7 @@ static int ocfs2_releasepage(struct page *page, gfp_t wait)
        if (!page_has_buffers(page))
                return 0;
-        return journal_try_to_free_buffers(journal, page, wait);
+        return jbd2_journal_try_to_free_buffers(journal, page, wait);
 }
 static ssize_t ocfs2_direct_IO(int rw,
@@ -1074,11 +1072,15 @@ static void ocfs2_write_failure(struct inode *inode,
                tmppage = wc->w_pages[i];
                if (page_has_buffers(tmppage)) {
-                        if (ocfs2_should_order_data(inode))
+                        if (ocfs2_should_order_data(inode)) {
+                                ocfs2_jbd2_file_inode(wc->w_handle, inode);
+#ifdef CONFIG_OCFS2_COMPAT_JBD
                                walk_page_buffers(wc->w_handle,
                                                  page_buffers(tmppage),
                                                  from, to, NULL,
                                                  ocfs2_journal_dirty_data);
+#endif
+                        }
                        block_commit_write(tmppage, from, to);
                }
@@ -1242,6 +1244,7 @@ static int ocfs2_write_cluster(struct address_space *mapping,
        int ret, i, new, should_zero = 0;
        u64 v_blkno, p_blkno;
        struct inode *inode = mapping->host;
+        struct ocfs2_extent_tree et;
        new = phys == 0 ? 1 : 0;
        if (new || unwritten)
@@ -1255,10 +1258,10 @@ static int ocfs2_write_cluster(struct address_space *mapping,
                 * any additional semaphores or cluster locks.
                 */
                tmp_pos = cpos;
-                ret = ocfs2_do_extend_allocation(OCFS2_SB(inode->i_sb), inode,
+                ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
-                                                 &tmp_pos, 1, 0, wc->w_di_bh,
+                                           &tmp_pos, 1, 0, wc->w_di_bh,
-                                                 wc->w_handle, data_ac,
+                                           wc->w_handle, data_ac,
-                                                 meta_ac, NULL);
+                                           meta_ac, NULL);
                /*
                 * This shouldn't happen because we must have already
                 * calculated the correct meta data allocation required. The
@@ -1276,7 +1279,8 @@ static int ocfs2_write_cluster(struct address_space *mapping,
                        goto out;
                }
        } else if (unwritten) {
-                ret = ocfs2_mark_extent_written(inode, wc->w_di_bh,
+                ocfs2_init_dinode_extent_tree(&et, inode, wc->w_di_bh);
+                ret = ocfs2_mark_extent_written(inode, &et,
                                                wc->w_handle, cpos, 1, phys,
                                                meta_ac, &wc->w_dealloc);
                if (ret < 0) {
@@ -1665,6 +1669,7 @@ int ocfs2_write_begin_nolock(struct address_space *mapping,
        struct ocfs2_alloc_context *data_ac = NULL;
        struct ocfs2_alloc_context *meta_ac = NULL;
        handle_t *handle;
+        struct ocfs2_extent_tree et;
        ret = ocfs2_alloc_write_ctxt(&wc, osb, pos, len, di_bh);
        if (ret) {
@@ -1712,14 +1717,23 @@ int ocfs2_write_begin_nolock(struct address_space *mapping,
                 * ocfs2_lock_allocators(). It greatly over-estimates
                 * the work to be done.
                 */
-                ret = ocfs2_lock_allocators(inode, di, clusters_to_alloc,
+                mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u,"
-                                            extents_to_split, &data_ac, &meta_ac);
+                     " clusters_to_add = %u, extents_to_split = %u\n",
+                     (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                     (long long)i_size_read(inode), le32_to_cpu(di->i_clusters),
+                     clusters_to_alloc, extents_to_split);
+                ocfs2_init_dinode_extent_tree(&et, inode, wc->w_di_bh);
+                ret = ocfs2_lock_allocators(inode, &et,
+                                            clusters_to_alloc, extents_to_split,
+                                            &data_ac, &meta_ac);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
                }
-                credits = ocfs2_calc_extend_credits(inode->i_sb, di,
+                credits = ocfs2_calc_extend_credits(inode->i_sb,
+                                                    &di->id2.i_list,
                                                    clusters_to_alloc);
        }
@@ -1905,11 +1919,15 @@ int ocfs2_write_end_nolock(struct address_space *mapping,
                }
                if (page_has_buffers(tmppage)) {
-                        if (ocfs2_should_order_data(inode))
+                        if (ocfs2_should_order_data(inode)) {
+                                ocfs2_jbd2_file_inode(wc->w_handle, inode);
+#ifdef CONFIG_OCFS2_COMPAT_JBD
                                walk_page_buffers(wc->w_handle,
                                                  page_buffers(tmppage),
                                                  from, to, NULL,
                                                  ocfs2_journal_dirty_data);
+#endif
+                        }
                        block_commit_write(tmppage, from, to);
                }
        }
diff --git a/fs/ocfs2/buffer_head_io.c b/fs/ocfs2/buffer_head_io.c
index f136639f5b41..7e947c672469 100644
--- a/fs/ocfs2/buffer_head_io.c
+++ b/fs/ocfs2/buffer_head_io.c
@@ -66,7 +66,7 @@ int ocfs2_write_block(struct ocfs2_super *osb, struct buffer_head *bh,
        /* remove from dirty list before I/O. */
        clear_buffer_dirty(bh);
-        get_bh(bh); /* for end_buffer_write_sync() */                   
+        get_bh(bh); /* for end_buffer_write_sync() */
        bh->b_end_io = end_buffer_write_sync;
        submit_bh(WRITE, bh);
@@ -88,22 +88,103 @@ out:
        return ret;
 }
-int ocfs2_read_blocks(struct ocfs2_super *osb, u64 block, int nr,
+int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block,
-                      struct buffer_head *bhs[], int flags,
+                           unsigned int nr, struct buffer_head *bhs[])
-                      struct inode *inode)
+{
+        int status = 0;
+        unsigned int i;
+        struct buffer_head *bh;
+        if (!nr) {
+                mlog(ML_BH_IO, "No buffers will be read!\n");
+                goto bail;
+        }
+        for (i = 0 ; i < nr ; i++) {
+                if (bhs[i] == NULL) {
+                        bhs[i] = sb_getblk(osb->sb, block++);
+                        if (bhs[i] == NULL) {
+                                status = -EIO;
+                                mlog_errno(status);
+                                goto bail;
+                        }
+                }
+                bh = bhs[i];
+                if (buffer_jbd(bh)) {
+                        mlog(ML_ERROR,
+                             "trying to sync read a jbd "
+                             "managed bh (blocknr = %llu), skipping\n",
+                             (unsigned long long)bh->b_blocknr);
+                        continue;
+                }
+                if (buffer_dirty(bh)) {
+                        /* This should probably be a BUG, or
+                         * at least return an error. */
+                        mlog(ML_ERROR,
+                             "trying to sync read a dirty "
+                             "buffer! (blocknr = %llu), skipping\n",
+                             (unsigned long long)bh->b_blocknr);
+                        continue;
+                }
+                lock_buffer(bh);
+                if (buffer_jbd(bh)) {
+                        mlog(ML_ERROR,
+                             "block %llu had the JBD bit set "
+                             "while I was in lock_buffer!",
+                             (unsigned long long)bh->b_blocknr);
+                        BUG();
+                }
+                clear_buffer_uptodate(bh);
+                get_bh(bh); /* for end_buffer_read_sync() */
+                bh->b_end_io = end_buffer_read_sync;
+                submit_bh(READ, bh);
+        }
+        for (i = nr; i > 0; i--) {
+                bh = bhs[i - 1];
+                if (buffer_jbd(bh)) {
+                        mlog(ML_ERROR,
+                             "the journal got the buffer while it was "
+                             "locked for io! (blocknr = %llu)\n",
+                             (unsigned long long)bh->b_blocknr);
+                        BUG();
+                }
+                wait_on_buffer(bh);
+                if (!buffer_uptodate(bh)) {
+                        /* Status won't be cleared from here on out,
+                         * so we can safely record this and loop back
+                         * to cleanup the other buffers. */
+                        status = -EIO;
+                        put_bh(bh);
+                        bhs[i - 1] = NULL;
+                }
+        }
+bail:
+        return status;
+}
+int ocfs2_read_blocks(struct inode *inode, u64 block, int nr,
+                      struct buffer_head *bhs[], int flags)
 {
        int status = 0;
-        struct super_block *sb;
        int i, ignore_cache = 0;
        struct buffer_head *bh;
-        mlog_entry("(block=(%llu), nr=(%d), flags=%d, inode=%p)\n",
+        mlog_entry("(inode=%p, block=(%llu), nr=(%d), flags=%d)\n",
-                   (unsigned long long)block, nr, flags, inode);
+                   inode, (unsigned long long)block, nr, flags);
+        BUG_ON(!inode);
        BUG_ON((flags & OCFS2_BH_READAHEAD) &&
-               (!inode || !(flags & OCFS2_BH_CACHED)));
+               (flags & OCFS2_BH_IGNORE_CACHE));
-        if (osb == NULL || osb->sb == NULL || bhs == NULL) {
+        if (bhs == NULL) {
                status = -EINVAL;
                mlog_errno(status);
                goto bail;
@@ -122,26 +203,19 @@ int ocfs2_read_blocks(struct ocfs2_super *osb, u64 block, int nr,
                goto bail;
        }
-        sb = osb->sb;
+        mutex_lock(&OCFS2_I(inode)->ip_io_mutex);
-        if (flags & OCFS2_BH_CACHED && !inode)
-                flags &= ~OCFS2_BH_CACHED;
-        if (inode)
-                mutex_lock(&OCFS2_I(inode)->ip_io_mutex);
        for (i = 0 ; i < nr ; i++) {
                if (bhs[i] == NULL) {
-                        bhs[i] = sb_getblk(sb, block++);
+                        bhs[i] = sb_getblk(inode->i_sb, block++);
                        if (bhs[i] == NULL) {
-                                if (inode)
+                                mutex_unlock(&OCFS2_I(inode)->ip_io_mutex);
-                                        mutex_unlock(&OCFS2_I(inode)->ip_io_mutex);
                                status = -EIO;
                                mlog_errno(status);
                                goto bail;
                        }
                }
                bh = bhs[i];
-                ignore_cache = 0;
+                ignore_cache = (flags & OCFS2_BH_IGNORE_CACHE);
                /* There are three read-ahead cases here which we need to
                 * be concerned with. All three assume a buffer has
@@ -167,26 +241,27 @@ int ocfs2_read_blocks(struct ocfs2_super *osb, u64 block, int nr,
                 *    before our is-it-in-flight check.
                 */
-                if (flags & OCFS2_BH_CACHED &&
+                if (!ignore_cache && !ocfs2_buffer_uptodate(inode, bh)) {
-                    !ocfs2_buffer_uptodate(inode, bh)) {
                        mlog(ML_UPTODATE,
                             "bh (%llu), inode %llu not uptodate\n",
                             (unsigned long long)bh->b_blocknr,
                             (unsigned long long)OCFS2_I(inode)->ip_blkno);
+                        /* We're using ignore_cache here to say
+                         * "go to disk" */
                        ignore_cache = 1;
                }
                /* XXX: Can we ever get this and *not* have the cached
                 * flag set? */
                if (buffer_jbd(bh)) {
-                        if (!(flags & OCFS2_BH_CACHED) || ignore_cache)
+                        if (ignore_cache)
                                mlog(ML_BH_IO, "trying to sync read a jbd "
                                               "managed bh (blocknr = %llu)\n",
                                     (unsigned long long)bh->b_blocknr);
                        continue;
                }
-                if (!(flags & OCFS2_BH_CACHED) || ignore_cache) {
+                if (ignore_cache) {
                        if (buffer_dirty(bh)) {
                                /* This should probably be a BUG, or
                                 * at least return an error. */
@@ -221,7 +296,7 @@ int ocfs2_read_blocks(struct ocfs2_super *osb, u64 block, int nr,
                         * previously read-ahead buffer may have
                         * completed I/O while we were waiting for the
                         * buffer lock. */
-                        if ((flags & OCFS2_BH_CACHED)
+                        if (!(flags & OCFS2_BH_IGNORE_CACHE)
                            && !(flags & OCFS2_BH_READAHEAD)
                            && ocfs2_buffer_uptodate(inode, bh)) {
                                unlock_buffer(bh);
@@ -265,15 +340,14 @@ int ocfs2_read_blocks(struct ocfs2_super *osb, u64 block, int nr,
                /* Always set the buffer in the cache, even if it was
                 * a forced read, or read-ahead which hasn't yet
                 * completed. */
-                if (inode)
+                ocfs2_set_buffer_uptodate(inode, bh);
-                        ocfs2_set_buffer_uptodate(inode, bh);
        }
-        if (inode)
+        mutex_unlock(&OCFS2_I(inode)->ip_io_mutex);
-                mutex_unlock(&OCFS2_I(inode)->ip_io_mutex);
        mlog(ML_BH_IO, "block=(%llu), nr=(%d), cached=%s, flags=0x%x\n", 
             (unsigned long long)block, nr,
-             (!(flags & OCFS2_BH_CACHED) || ignore_cache) ? "no" : "yes", flags);
+             ((flags & OCFS2_BH_IGNORE_CACHE) || ignore_cache) ? "no" : "yes",
+             flags);
 bail:
diff --git a/fs/ocfs2/buffer_head_io.h b/fs/ocfs2/buffer_head_io.h
index c2e78614c3e5..75e1dcb1ade7 100644
--- a/fs/ocfs2/buffer_head_io.h
+++ b/fs/ocfs2/buffer_head_io.h
@@ -31,31 +31,29 @@
 void ocfs2_end_buffer_io_sync(struct buffer_head *bh,
                             int uptodate);
-static inline int ocfs2_read_block(struct ocfs2_super          *osb,
+static inline int ocfs2_read_block(struct inode        *inode,
                                   u64                  off,
-                                   struct buffer_head **bh,
+                                   struct buffer_head **bh);
-                                   int                  flags,
-                                   struct inode        *inode);
 int ocfs2_write_block(struct ocfs2_super          *osb,
                      struct buffer_head  *bh,
                      struct inode        *inode);
-int ocfs2_read_blocks(struct ocfs2_super          *osb,
+int ocfs2_read_blocks(struct inode        *inode,
                      u64                  block,
                      int                  nr,
                      struct buffer_head  *bhs[],
-                      int                  flags,
+                      int                  flags);
-                      struct inode        *inode);
+int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block,
+                           unsigned int nr, struct buffer_head *bhs[]);
 int ocfs2_write_super_or_backup(struct ocfs2_super *osb,
                                struct buffer_head *bh);
-#define OCFS2_BH_CACHED            1
+#define OCFS2_BH_IGNORE_CACHE      1
 #define OCFS2_BH_READAHEAD         8
-static inline int ocfs2_read_block(struct ocfs2_super * osb, u64 off,
+static inline int ocfs2_read_block(struct inode *inode, u64 off,
-                                   struct buffer_head **bh, int flags,
+                                   struct buffer_head **bh)
-                                   struct inode *inode)
 {
        int status = 0;
@@ -65,8 +63,7 @@ static inline int ocfs2_read_block(struct ocfs2_super * osb, u64 off,
                goto bail;
        }
-        status = ocfs2_read_blocks(osb, off, 1, bh,
+        status = ocfs2_read_blocks(inode, off, 1, bh, 0);
-                                   flags, inode);
 bail:
        return status;
diff --git a/fs/ocfs2/cluster/masklog.c b/fs/ocfs2/cluster/masklog.c
index 23c732f27529..d8a0cb92cef6 100644
--- a/fs/ocfs2/cluster/masklog.c
+++ b/fs/ocfs2/cluster/masklog.c
@@ -109,6 +109,7 @@ static struct mlog_attribute mlog_attrs[MLOG_MAX_BITS] = {
        define_mask(CONN),
        define_mask(QUORUM),
        define_mask(EXPORT),
+        define_mask(XATTR),
        define_mask(ERROR),
        define_mask(NOTICE),
        define_mask(KTHREAD),
diff --git a/fs/ocfs2/cluster/masklog.h b/fs/ocfs2/cluster/masklog.h
index 597e064bb94f..57670c680471 100644
--- a/fs/ocfs2/cluster/masklog.h
+++ b/fs/ocfs2/cluster/masklog.h
@@ -112,6 +112,7 @@
 #define ML_CONN         0x0000000004000000ULL /* net connection management */
 #define ML_QUORUM       0x0000000008000000ULL /* net connection quorum */
 #define ML_EXPORT       0x0000000010000000ULL /* ocfs2 export operations */
+#define ML_XATTR        0x0000000020000000ULL /* ocfs2 extended attributes */
 /* bits that are infrequently given and frequently matched in the high word */
 #define ML_ERROR        0x0000000100000000ULL /* sent to KERN_ERR */
 #define ML_NOTICE       0x0000000200000000ULL /* setn to KERN_NOTICE */
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index 9cce563fd627..026e6eb85187 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -82,6 +82,49 @@ static int ocfs2_do_extend_dir(struct super_block *sb,
                               struct ocfs2_alloc_context *meta_ac,
                               struct buffer_head **new_bh);
+static struct buffer_head *ocfs2_bread(struct inode *inode,
+                                       int block, int *err, int reada)
+{
+        struct buffer_head *bh = NULL;
+        int tmperr;
+        u64 p_blkno;
+        int readflags = 0;
+        if (reada)
+                readflags |= OCFS2_BH_READAHEAD;
+        if (((u64)block << inode->i_sb->s_blocksize_bits) >=
+            i_size_read(inode)) {
+                BUG_ON(!reada);
+                return NULL;
+        }
+        down_read(&OCFS2_I(inode)->ip_alloc_sem);
+        tmperr = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
+                                             NULL);
+        up_read(&OCFS2_I(inode)->ip_alloc_sem);
+        if (tmperr < 0) {
+                mlog_errno(tmperr);
+                goto fail;
+        }
+        tmperr = ocfs2_read_blocks(inode, p_blkno, 1, &bh, readflags);
+        if (tmperr < 0)
+                goto fail;
+        tmperr = 0;
+        *err = 0;
+        return bh;
+fail:
+        brelse(bh);
+        bh = NULL;
+        *err = -EIO;
+        return NULL;
+}
 /*
 * bh passed here can be an inode block or a dir data block, depending
 * on the inode inline data flag.
@@ -188,8 +231,7 @@ static struct buffer_head *ocfs2_find_entry_id(const char *name,
        struct ocfs2_dinode *di;
        struct ocfs2_inline_data *data;
-        ret = ocfs2_read_block(OCFS2_SB(dir->i_sb), OCFS2_I(dir)->ip_blkno,
+        ret = ocfs2_read_block(dir, OCFS2_I(dir)->ip_blkno, &di_bh);
-                               &di_bh, OCFS2_BH_CACHED, dir);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -260,14 +302,13 @@ restart:
                }
                if ((bh = bh_use[ra_ptr++]) == NULL)
                        goto next;
-                wait_on_buffer(bh);
+                if (ocfs2_read_block(dir, block, &bh)) {
-                if (!buffer_uptodate(bh)) {
+                        /* read error, skip block & hope for the best.
-                        /* read error, skip block & hope for the best */
+                         * ocfs2_read_block() has released the bh. */
                        ocfs2_error(dir->i_sb, "reading directory %llu, "
                                    "offset %lu\n",
                                    (unsigned long long)OCFS2_I(dir)->ip_blkno,
                                    block);
-                        brelse(bh);
                        goto next;
                }
                i = ocfs2_search_dirblock(bh, dir, name, namelen,
@@ -417,8 +458,7 @@ static inline int ocfs2_delete_entry_id(handle_t *handle,
        struct ocfs2_dinode *di;
        struct ocfs2_inline_data *data;
-        ret = ocfs2_read_block(OCFS2_SB(dir->i_sb), OCFS2_I(dir)->ip_blkno,
+        ret = ocfs2_read_block(dir, OCFS2_I(dir)->ip_blkno, &di_bh);
-                               &di_bh, OCFS2_BH_CACHED, dir);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -596,8 +636,7 @@ static int ocfs2_dir_foreach_blk_id(struct inode *inode,
        struct ocfs2_inline_data *data;
        struct ocfs2_dir_entry *de;
-        ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), OCFS2_I(inode)->ip_blkno,
+        ret = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, &di_bh);
-                               &di_bh, OCFS2_BH_CACHED, inode);
        if (ret) {
                mlog(ML_ERROR, "Unable to read inode block for dir %llu\n",
                     (unsigned long long)OCFS2_I(inode)->ip_blkno);
@@ -716,8 +755,7 @@ static int ocfs2_dir_foreach_blk_el(struct inode *inode,
                        for (i = ra_sectors >> (sb->s_blocksize_bits - 9);
                             i > 0; i--) {
                                tmp = ocfs2_bread(inode, ++blk, &err, 1);
-                                if (tmp)
+                                brelse(tmp);
-                                        brelse(tmp);
                        }
                        last_ra_blk = blk;
                        ra_sectors = 8;
@@ -899,10 +937,8 @@ int ocfs2_find_files_on_disk(const char *name,
 leave:
        if (status < 0) {
                *dirent = NULL;
-                if (*dirent_bh) {
+                brelse(*dirent_bh);
-                        brelse(*dirent_bh);
+                *dirent_bh = NULL;
-                        *dirent_bh = NULL;
-                }
        }
        mlog_exit(status);
@@ -951,8 +987,7 @@ int ocfs2_check_dir_for_entry(struct inode *dir,
        ret = 0;
 bail:
-        if (dirent_bh)
+        brelse(dirent_bh);
-                brelse(dirent_bh);
        mlog_exit(ret);
        return ret;
@@ -1127,8 +1162,7 @@ static int ocfs2_fill_new_dir_el(struct ocfs2_super *osb,
        status = 0;
 bail:
-        if (new_bh)
+        brelse(new_bh);
-                brelse(new_bh);
        mlog_exit(status);
        return status;
@@ -1192,6 +1226,9 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
        struct buffer_head *dirdata_bh = NULL;
        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
        handle_t *handle;
+        struct ocfs2_extent_tree et;
+        ocfs2_init_dinode_extent_tree(&et, dir, di_bh);
        alloc = ocfs2_clusters_for_bytes(sb, bytes);
@@ -1305,8 +1342,8 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
         * This should never fail as our extent list is empty and all
         * related blocks have been journaled already.
         */
-        ret = ocfs2_insert_extent(osb, handle, dir, di_bh, 0, blkno, len, 0,
+        ret = ocfs2_insert_extent(osb, handle, dir, &et, 0, blkno, len,
-                                  NULL);
+                                  0, NULL);
        if (ret) {
                mlog_errno(ret);
                goto out_commit;
@@ -1337,8 +1374,8 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
                }
                blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off);
-                ret = ocfs2_insert_extent(osb, handle, dir, di_bh, 1, blkno,
+                ret = ocfs2_insert_extent(osb, handle, dir, &et, 1,
-                                          len, 0, NULL);
+                                          blkno, len, 0, NULL);
                if (ret) {
                        mlog_errno(ret);
                        goto out_commit;
@@ -1383,9 +1420,9 @@ static int ocfs2_do_extend_dir(struct super_block *sb,
        if (extend) {
                u32 offset = OCFS2_I(dir)->ip_clusters;
-                status = ocfs2_do_extend_allocation(OCFS2_SB(sb), dir, &offset,
+                status = ocfs2_add_inode_data(OCFS2_SB(sb), dir, &offset,
-                                                    1, 0, parent_fe_bh, handle,
+                                              1, 0, parent_fe_bh, handle,
-                                                    data_ac, meta_ac, NULL);
+                                              data_ac, meta_ac, NULL);
                BUG_ON(status == -EAGAIN);
                if (status < 0) {
                        mlog_errno(status);
@@ -1430,12 +1467,14 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
        int credits, num_free_extents, drop_alloc_sem = 0;
        loff_t dir_i_size;
        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
+        struct ocfs2_extent_list *el = &fe->id2.i_list;
        struct ocfs2_alloc_context *data_ac = NULL;
        struct ocfs2_alloc_context *meta_ac = NULL;
        handle_t *handle = NULL;
        struct buffer_head *new_bh = NULL;
        struct ocfs2_dir_entry * de;
        struct super_block *sb = osb->sb;
+        struct ocfs2_extent_tree et;
        mlog_entry_void();
@@ -1479,7 +1518,8 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
        spin_lock(&OCFS2_I(dir)->ip_lock);
        if (dir_i_size == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters)) {
                spin_unlock(&OCFS2_I(dir)->ip_lock);
-                num_free_extents = ocfs2_num_free_extents(osb, dir, fe);
+                ocfs2_init_dinode_extent_tree(&et, dir, parent_fe_bh);
+                num_free_extents = ocfs2_num_free_extents(osb, dir, &et);
                if (num_free_extents < 0) {
                        status = num_free_extents;
                        mlog_errno(status);
@@ -1487,7 +1527,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                }
                if (!num_free_extents) {
-                        status = ocfs2_reserve_new_metadata(osb, fe, &meta_ac);
+                        status = ocfs2_reserve_new_metadata(osb, el, &meta_ac);
                        if (status < 0) {
                                if (status != -ENOSPC)
                                        mlog_errno(status);
@@ -1502,7 +1542,7 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
                        goto bail;
                }
-                credits = ocfs2_calc_extend_credits(sb, fe, 1);
+                credits = ocfs2_calc_extend_credits(sb, el, 1);
        } else {
                spin_unlock(&OCFS2_I(dir)->ip_lock);
                credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
@@ -1568,8 +1608,7 @@ bail:
        if (meta_ac)
                ocfs2_free_alloc_context(meta_ac);
-        if (new_bh)
+        brelse(new_bh);
-                brelse(new_bh);
        mlog_exit(status);
        return status;
@@ -1696,8 +1735,7 @@ static int ocfs2_find_dir_space_el(struct inode *dir, const char *name,
        status = 0;
 bail:
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(status);
        return status;
@@ -1756,7 +1794,6 @@ int ocfs2_prepare_dir_for_insert(struct ocfs2_super *osb,
        *ret_de_bh = bh;
        bh = NULL;
 out:
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        return ret;
 }
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index eae3d643a5e4..ec684426034b 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -2024,8 +2024,7 @@ static int ocfs2_inode_lock_update(struct inode *inode,
        } else {
                /* Boo, we have to go to disk. */
                /* read bh, cast, ocfs2_refresh_inode */
-                status = ocfs2_read_block(OCFS2_SB(inode->i_sb), oi->ip_blkno,
+                status = ocfs2_read_block(inode, oi->ip_blkno, bh);
-                                          bh, OCFS2_BH_CACHED, inode);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail_refresh;
@@ -2086,11 +2085,7 @@ static int ocfs2_assign_bh(struct inode *inode,
                return 0;
        }
-        status = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+        status = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, ret_bh);
-                                  OCFS2_I(inode)->ip_blkno,
-                                  ret_bh,
-                                  OCFS2_BH_CACHED,
-                                  inode);
        if (status < 0)
                mlog_errno(status);
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c
index aed268e80b49..2baedac58234 100644
--- a/fs/ocfs2/extent_map.c
+++ b/fs/ocfs2/extent_map.c
@@ -293,8 +293,7 @@ static int ocfs2_last_eb_is_empty(struct inode *inode,
        struct ocfs2_extent_block *eb;
        struct ocfs2_extent_list *el;
-        ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), last_eb_blk,
+        ret = ocfs2_read_block(inode, last_eb_blk, &eb_bh);
-                               &eb_bh, OCFS2_BH_CACHED, inode);
        if (ret) {
                mlog_errno(ret);
                goto out;
@@ -382,9 +381,9 @@ static int ocfs2_figure_hole_clusters(struct inode *inode,
                if (le64_to_cpu(eb->h_next_leaf_blk) == 0ULL)
                        goto no_more_extents;
-                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                ret = ocfs2_read_block(inode,
                                       le64_to_cpu(eb->h_next_leaf_blk),
-                                       &next_eb_bh, OCFS2_BH_CACHED, inode);
+                                       &next_eb_bh);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -551,6 +550,66 @@ static void ocfs2_relative_extent_offsets(struct super_block *sb,
                *num_clusters = le16_to_cpu(rec->e_leaf_clusters) - coff;
 }
+int ocfs2_xattr_get_clusters(struct inode *inode, u32 v_cluster,
+                             u32 *p_cluster, u32 *num_clusters,
+                             struct ocfs2_extent_list *el)
+{
+        int ret = 0, i;
+        struct buffer_head *eb_bh = NULL;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_extent_rec *rec;
+        u32 coff;
+        if (el->l_tree_depth) {
+                ret = ocfs2_find_leaf(inode, el, v_cluster, &eb_bh);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                eb = (struct ocfs2_extent_block *) eb_bh->b_data;
+                el = &eb->h_list;
+                if (el->l_tree_depth) {
+                        ocfs2_error(inode->i_sb,
+                                    "Inode %lu has non zero tree depth in "
+                                    "xattr leaf block %llu\n", inode->i_ino,
+                                    (unsigned long long)eb_bh->b_blocknr);
+                        ret = -EROFS;
+                        goto out;
+                }
+        }
+        i = ocfs2_search_extent_list(el, v_cluster);
+        if (i == -1) {
+                ret = -EROFS;
+                mlog_errno(ret);
+                goto out;
+        } else {
+                rec = &el->l_recs[i];
+                BUG_ON(v_cluster < le32_to_cpu(rec->e_cpos));
+                if (!rec->e_blkno) {
+                        ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
+                                    "record (%u, %u, 0) in xattr", inode->i_ino,
+                                    le32_to_cpu(rec->e_cpos),
+                                    ocfs2_rec_clusters(el, rec));
+                        ret = -EROFS;
+                        goto out;
+                }
+                coff = v_cluster - le32_to_cpu(rec->e_cpos);
+                *p_cluster = ocfs2_blocks_to_clusters(inode->i_sb,
+                                                    le64_to_cpu(rec->e_blkno));
+                *p_cluster = *p_cluster + coff;
+                if (num_clusters)
+                        *num_clusters = ocfs2_rec_clusters(el, rec) - coff;
+        }
+out:
+        if (eb_bh)
+                brelse(eb_bh);
+        return ret;
+}
 int ocfs2_get_clusters(struct inode *inode, u32 v_cluster,
                       u32 *p_cluster, u32 *num_clusters,
                       unsigned int *extent_flags)
@@ -571,8 +630,7 @@ int ocfs2_get_clusters(struct inode *inode, u32 v_cluster,
        if (ret == 0)
                goto out;
-        ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), OCFS2_I(inode)->ip_blkno,
+        ret = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, &di_bh);
-                               &di_bh, OCFS2_BH_CACHED, inode);
        if (ret) {
                mlog_errno(ret);
                goto out;
diff --git a/fs/ocfs2/extent_map.h b/fs/ocfs2/extent_map.h
index 1b97490e1ea8..1c4aa8b06f34 100644
--- a/fs/ocfs2/extent_map.h
+++ b/fs/ocfs2/extent_map.h
@@ -53,4 +53,8 @@ int ocfs2_extent_map_get_blocks(struct inode *inode, u64 v_blkno, u64 *p_blkno,
 int ocfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                 u64 map_start, u64 map_len);
+int ocfs2_xattr_get_clusters(struct inode *inode, u32 v_cluster,
+                             u32 *p_cluster, u32 *num_clusters,
+                             struct ocfs2_extent_list *el);
 #endif  /* _EXTENT_MAP_H */
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index ed38796052d2..8d3225a78073 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -55,6 +55,7 @@
 #include "mmap.h"
 #include "suballoc.h"
 #include "super.h"
+#include "xattr.h"
 #include "buffer_head_io.h"
@@ -184,7 +185,7 @@ static int ocfs2_sync_file(struct file *file,
                goto bail;
        journal = osb->journal->j_journal;
-        err = journal_force_commit(journal);
+        err = jbd2_journal_force_commit(journal);
 bail:
        mlog_exit(err);
@@ -488,7 +489,7 @@ bail:
 }
 /*
- * extend allocation only here.
+ * extend file allocation only here.
 * we'll update all the disk stuff, and oip->alloc_size
 *
 * expect stuff to be locked, a transaction started and enough data /
@@ -497,189 +498,25 @@ bail:
 * Will return -EAGAIN, and a reason if a restart is needed.
 * If passed in, *reason will always be set, even in error.
 */
-int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
+int ocfs2_add_inode_data(struct ocfs2_super *osb,
-                               struct inode *inode,
+                         struct inode *inode,
-                               u32 *logical_offset,
+                         u32 *logical_offset,
-                               u32 clusters_to_add,
+                         u32 clusters_to_add,
-                               int mark_unwritten,
+                         int mark_unwritten,
-                               struct buffer_head *fe_bh,
+                         struct buffer_head *fe_bh,
-                               handle_t *handle,
+                         handle_t *handle,
-                               struct ocfs2_alloc_context *data_ac,
+                         struct ocfs2_alloc_context *data_ac,
-                               struct ocfs2_alloc_context *meta_ac,
+                         struct ocfs2_alloc_context *meta_ac,
-                               enum ocfs2_alloc_restarted *reason_ret)
+                         enum ocfs2_alloc_restarted *reason_ret)
 {
-        int status = 0;
+        int ret;
-        int free_extents;
+        struct ocfs2_extent_tree et;
-        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
-        enum ocfs2_alloc_restarted reason = RESTART_NONE;
-        u32 bit_off, num_bits;
-        u64 block;
-        u8 flags = 0;
-        BUG_ON(!clusters_to_add);
-        if (mark_unwritten)
-                flags = OCFS2_EXT_UNWRITTEN;
-        free_extents = ocfs2_num_free_extents(osb, inode, fe);
-        if (free_extents < 0) {
-                status = free_extents;
-                mlog_errno(status);
-                goto leave;
-        }
-        /* there are two cases which could cause us to EAGAIN in the
-         * we-need-more-metadata case:
-         * 1) we haven't reserved *any*
-         * 2) we are so fragmented, we've needed to add metadata too
-         *    many times. */
-        if (!free_extents && !meta_ac) {
-                mlog(0, "we haven't reserved any metadata!\n");
-                status = -EAGAIN;
-                reason = RESTART_META;
-                goto leave;
-        } else if ((!free_extents)
-                   && (ocfs2_alloc_context_bits_left(meta_ac)
-                       < ocfs2_extend_meta_needed(fe))) {
-                mlog(0, "filesystem is really fragmented...\n");
-                status = -EAGAIN;
-                reason = RESTART_META;
-                goto leave;
-        }
-        status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
-                                        clusters_to_add, &bit_off, &num_bits);
-        if (status < 0) {
-                if (status != -ENOSPC)
-                        mlog_errno(status);
-                goto leave;
-        }
-        BUG_ON(num_bits > clusters_to_add);
-        /* reserve our write early -- insert_extent may update the inode */
-        status = ocfs2_journal_access(handle, inode, fe_bh,
-                                      OCFS2_JOURNAL_ACCESS_WRITE);
-        if (status < 0) {
-                mlog_errno(status);
-                goto leave;
-        }
-        block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
-        mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
-             num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
-        status = ocfs2_insert_extent(osb, handle, inode, fe_bh,
-                                     *logical_offset, block, num_bits,
-                                     flags, meta_ac);
-        if (status < 0) {
-                mlog_errno(status);
-                goto leave;
-        }
-        status = ocfs2_journal_dirty(handle, fe_bh);
-        if (status < 0) {
-                mlog_errno(status);
-                goto leave;
-        }
-        clusters_to_add -= num_bits;
-        *logical_offset += num_bits;
-        if (clusters_to_add) {
-                mlog(0, "need to alloc once more, clusters = %u, wanted = "
-                     "%u\n", fe->i_clusters, clusters_to_add);
-                status = -EAGAIN;
-                reason = RESTART_TRANS;
-        }
-leave:
-        mlog_exit(status);
-        if (reason_ret)
-                *reason_ret = reason;
-        return status;
-}
-/*
- * For a given allocation, determine which allocators will need to be
- * accessed, and lock them, reserving the appropriate number of bits.
- *
- * Sparse file systems call this from ocfs2_write_begin_nolock()
- * and ocfs2_allocate_unwritten_extents().
- *
- * File systems which don't support holes call this from
- * ocfs2_extend_allocation().
- */
-int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
-                          u32 clusters_to_add, u32 extents_to_split,
-                          struct ocfs2_alloc_context **data_ac,
-                          struct ocfs2_alloc_context **meta_ac)
-{
-        int ret = 0, num_free_extents;
-        unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split;
-        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-        *meta_ac = NULL;
-        if (data_ac)
-                *data_ac = NULL;
-        BUG_ON(clusters_to_add != 0 && data_ac == NULL);
-        mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u, "
-             "clusters_to_add = %u, extents_to_split = %u\n",
-             (unsigned long long)OCFS2_I(inode)->ip_blkno, (long long)i_size_read(inode),
-             le32_to_cpu(di->i_clusters), clusters_to_add, extents_to_split);
-        num_free_extents = ocfs2_num_free_extents(osb, inode, di);
-        if (num_free_extents < 0) {
-                ret = num_free_extents;
-                mlog_errno(ret);
-                goto out;
-        }
-        /*
-         * Sparse allocation file systems need to be more conservative
-         * with reserving room for expansion - the actual allocation
-         * happens while we've got a journal handle open so re-taking
-         * a cluster lock (because we ran out of room for another
-         * extent) will violate ordering rules.
-         *
-         * Most of the time we'll only be seeing this 1 cluster at a time
-         * anyway.
-         *
-         * Always lock for any unwritten extents - we might want to
-         * add blocks during a split.
-         */
-        if (!num_free_extents ||
-            (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) {
-                ret = ocfs2_reserve_new_metadata(osb, di, meta_ac);
-                if (ret < 0) {
-                        if (ret != -ENOSPC)
-                                mlog_errno(ret);
-                        goto out;
-                }
-        }
-        if (clusters_to_add == 0)
-                goto out;
-        ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac);
-        if (ret < 0) {
-                if (ret != -ENOSPC)
-                        mlog_errno(ret);
-                goto out;
-        }
-out:
-        if (ret) {
-                if (*meta_ac) {
-                        ocfs2_free_alloc_context(*meta_ac);
-                        *meta_ac = NULL;
-                }
-                /*
+        ocfs2_init_dinode_extent_tree(&et, inode, fe_bh);
-                 * We cannot have an error and a non null *data_ac.
+        ret = ocfs2_add_clusters_in_btree(osb, inode, logical_offset,
-                 */
+                                           clusters_to_add, mark_unwritten,
-        }
+                                           &et, handle,
+                                           data_ac, meta_ac, reason_ret);
        return ret;
 }
@@ -698,6 +535,7 @@ static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
        struct ocfs2_alloc_context *meta_ac = NULL;
        enum ocfs2_alloc_restarted why;
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_extent_tree et;
        mlog_entry("(clusters_to_add = %u)\n", clusters_to_add);
@@ -707,8 +545,7 @@ static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
         */
        BUG_ON(mark_unwritten && !ocfs2_sparse_alloc(osb));
-        status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
+        status = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, &bh);
-                                  OCFS2_BH_CACHED, inode);
        if (status < 0) {
                mlog_errno(status);
                goto leave;
@@ -724,14 +561,21 @@ static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
 restart_all:
        BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters);
-        status = ocfs2_lock_allocators(inode, fe, clusters_to_add, 0, &data_ac,
+        mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u, "
-                                       &meta_ac);
+             "clusters_to_add = %u\n",
+             (unsigned long long)OCFS2_I(inode)->ip_blkno,
+             (long long)i_size_read(inode), le32_to_cpu(fe->i_clusters),
+             clusters_to_add);
+        ocfs2_init_dinode_extent_tree(&et, inode, bh);
+        status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
+                                       &data_ac, &meta_ac);
        if (status) {
                mlog_errno(status);
                goto leave;
        }
-        credits = ocfs2_calc_extend_credits(osb->sb, fe, clusters_to_add);
+        credits = ocfs2_calc_extend_credits(osb->sb, &fe->id2.i_list,
+                                            clusters_to_add);
        handle = ocfs2_start_trans(osb, credits);
        if (IS_ERR(handle)) {
                status = PTR_ERR(handle);
@@ -753,16 +597,16 @@ restarted_transaction:
        prev_clusters = OCFS2_I(inode)->ip_clusters;
-        status = ocfs2_do_extend_allocation(osb,
+        status = ocfs2_add_inode_data(osb,
-                                            inode,
+                                      inode,
-                                            &logical_start,
+                                      &logical_start,
-                                            clusters_to_add,
+                                      clusters_to_add,
-                                            mark_unwritten,
+                                      mark_unwritten,
-                                            bh,
+                                      bh,
-                                            handle,
+                                      handle,
-                                            data_ac,
+                                      data_ac,
-                                            meta_ac,
+                                      meta_ac,
-                                            &why);
+                                      &why);
        if ((status < 0) && (status != -EAGAIN)) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -789,7 +633,7 @@ restarted_transaction:
                        mlog(0, "restarting transaction.\n");
                        /* TODO: This can be more intelligent. */
                        credits = ocfs2_calc_extend_credits(osb->sb,
-                                                            fe,
+                                                            &fe->id2.i_list,
                                                            clusters_to_add);
                        status = ocfs2_extend_trans(handle, credits);
                        if (status < 0) {
@@ -826,10 +670,8 @@ leave:
                restart_func = 0;
                goto restart_all;
        }
-        if (bh) {
+        brelse(bh);
-                brelse(bh);
+        bh = NULL;
-                bh = NULL;
-        }
        mlog_exit(status);
        return status;
@@ -1096,9 +938,15 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                        goto bail_unlock;
                }
-                if (i_size_read(inode) > attr->ia_size)
+                if (i_size_read(inode) > attr->ia_size) {
+                        if (ocfs2_should_order_data(inode)) {
+                                status = ocfs2_begin_ordered_truncate(inode,
+                                                                      attr->ia_size);
+                                if (status)
+                                        goto bail_unlock;
+                        }
                        status = ocfs2_truncate_file(inode, bh, attr->ia_size);
-                else
+                } else
                        status = ocfs2_extend_file(inode, bh, attr->ia_size);
                if (status < 0) {
                        if (status != -ENOSPC)
@@ -1140,8 +988,7 @@ bail_unlock_rw:
        if (size_change)
                ocfs2_rw_unlock(inode, 1);
 bail:
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(status);
        return status;
@@ -1284,8 +1131,7 @@ static int ocfs2_write_remove_suid(struct inode *inode)
        struct buffer_head *bh = NULL;
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
-        ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+        ret = ocfs2_read_block(inode, oi->ip_blkno, &bh);
-                               oi->ip_blkno, &bh, OCFS2_BH_CACHED, inode);
        if (ret < 0) {
                mlog_errno(ret);
                goto out;
@@ -1311,9 +1157,8 @@ static int ocfs2_allocate_unwritten_extents(struct inode *inode,
        struct buffer_head *di_bh = NULL;
        if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
-                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                ret = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno,
-                                       OCFS2_I(inode)->ip_blkno, &di_bh,
+                                       &di_bh);
-                                       OCFS2_BH_CACHED, inode);
                if (ret) {
                        mlog_errno(ret);
                        goto out;
@@ -1394,8 +1239,11 @@ static int __ocfs2_remove_inode_range(struct inode *inode,
        handle_t *handle;
        struct ocfs2_alloc_context *meta_ac = NULL;
        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        struct ocfs2_extent_tree et;
-        ret = ocfs2_lock_allocators(inode, di, 0, 1, NULL, &meta_ac);
+        ocfs2_init_dinode_extent_tree(&et, inode, di_bh);
+        ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
        if (ret) {
                mlog_errno(ret);
                return ret;
@@ -1425,7 +1273,7 @@ static int __ocfs2_remove_inode_range(struct inode *inode,
                goto out;
        }
-        ret = ocfs2_remove_extent(inode, di_bh, cpos, len, handle, meta_ac,
+        ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac,
                                  dealloc);
        if (ret) {
                mlog_errno(ret);
@@ -2040,7 +1888,7 @@ out_dio:
                 */
                if (old_size != i_size_read(inode) ||
                    old_clusters != OCFS2_I(inode)->ip_clusters) {
-                        ret = journal_force_commit(osb->journal->j_journal);
+                        ret = jbd2_journal_force_commit(osb->journal->j_journal);
                        if (ret < 0)
                                written = ret;
                }
@@ -2227,6 +2075,10 @@ const struct inode_operations ocfs2_file_iops = {
        .setattr        = ocfs2_setattr,
        .getattr        = ocfs2_getattr,
        .permission     = ocfs2_permission,
+        .setxattr       = generic_setxattr,
+        .getxattr       = generic_getxattr,
+        .listxattr      = ocfs2_listxattr,
+        .removexattr    = generic_removexattr,
        .fallocate      = ocfs2_fallocate,
        .fiemap         = ocfs2_fiemap,
 };
@@ -2237,6 +2089,10 @@ const struct inode_operations ocfs2_special_file_iops = {
        .permission     = ocfs2_permission,
 };
+/*
+ * Other than ->lock, keep ocfs2_fops and ocfs2_dops in sync with
+ * ocfs2_fops_no_plocks and ocfs2_dops_no_plocks!
+ */
 const struct file_operations ocfs2_fops = {
        .llseek         = generic_file_llseek,
        .read           = do_sync_read,
@@ -2251,6 +2107,7 @@ const struct file_operations ocfs2_fops = {
 #ifdef CONFIG_COMPAT
        .compat_ioctl   = ocfs2_compat_ioctl,
 #endif
+        .lock           = ocfs2_lock,
        .flock          = ocfs2_flock,
        .splice_read    = ocfs2_file_splice_read,
        .splice_write   = ocfs2_file_splice_write,
@@ -2267,5 +2124,51 @@ const struct file_operations ocfs2_dops = {
 #ifdef CONFIG_COMPAT
        .compat_ioctl   = ocfs2_compat_ioctl,
 #endif
+        .lock           = ocfs2_lock,
+        .flock          = ocfs2_flock,
+};
+/*
+ * POSIX-lockless variants of our file_operations.
+ *
+ * These will be used if the underlying cluster stack does not support
+ * posix file locking, if the user passes the "localflocks" mount
+ * option, or if we have a local-only fs.
+ *
+ * ocfs2_flock is in here because all stacks handle UNIX file locks,
+ * so we still want it in the case of no stack support for
+ * plocks. Internally, it will do the right thing when asked to ignore
+ * the cluster.
+ */
+const struct file_operations ocfs2_fops_no_plocks = {
+        .llseek         = generic_file_llseek,
+        .read           = do_sync_read,
+        .write          = do_sync_write,
+        .mmap           = ocfs2_mmap,
+        .fsync          = ocfs2_sync_file,
+        .release        = ocfs2_file_release,
+        .open           = ocfs2_file_open,
+        .aio_read       = ocfs2_file_aio_read,
+        .aio_write      = ocfs2_file_aio_write,
+        .unlocked_ioctl = ocfs2_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ocfs2_compat_ioctl,
+#endif
+        .flock          = ocfs2_flock,
+        .splice_read    = ocfs2_file_splice_read,
+        .splice_write   = ocfs2_file_splice_write,
+};
+const struct file_operations ocfs2_dops_no_plocks = {
+        .llseek         = generic_file_llseek,
+        .read           = generic_read_dir,
+        .readdir        = ocfs2_readdir,
+        .fsync          = ocfs2_sync_file,
+        .release        = ocfs2_dir_release,
+        .open           = ocfs2_dir_open,
+        .unlocked_ioctl = ocfs2_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ocfs2_compat_ioctl,
+#endif
        .flock          = ocfs2_flock,
 };
diff --git a/fs/ocfs2/file.h b/fs/ocfs2/file.h
index 1e27b4d017ea..e92382cbca5f 100644
--- a/fs/ocfs2/file.h
+++ b/fs/ocfs2/file.h
@@ -28,9 +28,12 @@
 extern const struct file_operations ocfs2_fops;
 extern const struct file_operations ocfs2_dops;
+extern const struct file_operations ocfs2_fops_no_plocks;
+extern const struct file_operations ocfs2_dops_no_plocks;
 extern const struct inode_operations ocfs2_file_iops;
 extern const struct inode_operations ocfs2_special_file_iops;
 struct ocfs2_alloc_context;
+enum ocfs2_alloc_restarted;
 struct ocfs2_file_private {
        struct file             *fp_file;
@@ -38,27 +41,18 @@ struct ocfs2_file_private {
        struct ocfs2_lock_res   fp_flock;
 };
-enum ocfs2_alloc_restarted {
+int ocfs2_add_inode_data(struct ocfs2_super *osb,
-        RESTART_NONE = 0,
+                         struct inode *inode,
-        RESTART_TRANS,
+                         u32 *logical_offset,
-        RESTART_META
+                         u32 clusters_to_add,
-};
+                         int mark_unwritten,
-int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
+                         struct buffer_head *fe_bh,
-                               struct inode *inode,
+                         handle_t *handle,
-                               u32 *logical_offset,
+                         struct ocfs2_alloc_context *data_ac,
-                               u32 clusters_to_add,
+                         struct ocfs2_alloc_context *meta_ac,
-                               int mark_unwritten,
+                         enum ocfs2_alloc_restarted *reason_ret);
-                               struct buffer_head *fe_bh,
-                               handle_t *handle,
-                               struct ocfs2_alloc_context *data_ac,
-                               struct ocfs2_alloc_context *meta_ac,
-                               enum ocfs2_alloc_restarted *reason_ret);
 int ocfs2_extend_no_holes(struct inode *inode, u64 new_i_size,
                          u64 zero_to);
-int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
-                          u32 clusters_to_add, u32 extents_to_split,
-                          struct ocfs2_alloc_context **data_ac,
-                          struct ocfs2_alloc_context **meta_ac);
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr);
 int ocfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat);
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 7e9e4c79aec7..4903688f72a9 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -49,6 +49,7 @@
 #include "symlink.h"
 #include "sysfile.h"
 #include "uptodate.h"
+#include "xattr.h"
 #include "buffer_head_io.h"
@@ -219,6 +220,7 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
        struct super_block *sb;
        struct ocfs2_super *osb;
        int status = -EINVAL;
+        int use_plocks = 1;
        mlog_entry("(0x%p, size:%llu)\n", inode,
                   (unsigned long long)le64_to_cpu(fe->i_size));
@@ -226,6 +228,10 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
        sb = inode->i_sb;
        osb = OCFS2_SB(sb);
+        if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) ||
+            ocfs2_mount_local(osb) || !ocfs2_stack_supports_plocks())
+                use_plocks = 0;
        /* this means that read_inode cannot create a superblock inode
         * today.  change if needed. */
        if (!OCFS2_IS_VALID_DINODE(fe) ||
@@ -295,13 +301,19 @@ int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
        switch (inode->i_mode & S_IFMT) {
            case S_IFREG:
-                    inode->i_fop = &ocfs2_fops;
+                    if (use_plocks)
+                            inode->i_fop = &ocfs2_fops;
+                    else
+                            inode->i_fop = &ocfs2_fops_no_plocks;
                    inode->i_op = &ocfs2_file_iops;
                    i_size_write(inode, le64_to_cpu(fe->i_size));
                    break;
            case S_IFDIR:
                    inode->i_op = &ocfs2_dir_iops;
-                    inode->i_fop = &ocfs2_dops;
+                    if (use_plocks)
+                            inode->i_fop = &ocfs2_dops;
+                    else
+                            inode->i_fop = &ocfs2_dops_no_plocks;
                    i_size_write(inode, le64_to_cpu(fe->i_size));
                    break;
            case S_IFLNK:
@@ -448,8 +460,11 @@ static int ocfs2_read_locked_inode(struct inode *inode,
                }
        }
-        status = ocfs2_read_block(osb, args->fi_blkno, &bh, 0,
+        if (can_lock)
-                                  can_lock ? inode : NULL);
+                status = ocfs2_read_blocks(inode, args->fi_blkno, 1, &bh,
+                                           OCFS2_BH_IGNORE_CACHE);
+        else
+                status = ocfs2_read_blocks_sync(osb, args->fi_blkno, 1, &bh);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -522,6 +537,9 @@ static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
         * data and fast symlinks.
         */
        if (fe->i_clusters) {
+                if (ocfs2_should_order_data(inode))
+                        ocfs2_begin_ordered_truncate(inode, 0);
                handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
                if (IS_ERR(handle)) {
                        status = PTR_ERR(handle);
@@ -730,6 +748,13 @@ static int ocfs2_wipe_inode(struct inode *inode,
                goto bail_unlock_dir;
        }
+        /*Free extended attribute resources associated with this inode.*/
+        status = ocfs2_xattr_remove(inode, di_bh);
+        if (status < 0) {
+                mlog_errno(status);
+                goto bail_unlock_dir;
+        }
        status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode,
                                    orphan_dir_bh);
        if (status < 0)
@@ -1081,6 +1106,8 @@ void ocfs2_clear_inode(struct inode *inode)
        oi->ip_last_trans = 0;
        oi->ip_dir_start_lookup = 0;
        oi->ip_blkno = 0ULL;
+        jbd2_journal_release_jbd_inode(OCFS2_SB(inode->i_sb)->journal->j_journal,
+                                       &oi->ip_jinode);
 bail:
        mlog_exit_void();
@@ -1107,58 +1134,6 @@ void ocfs2_drop_inode(struct inode *inode)
 }
 /*
- * TODO: this should probably be merged into ocfs2_get_block
- *
- * However, you now need to pay attention to the cont_prepare_write()
- * stuff in ocfs2_get_block (that is, ocfs2_get_block pretty much
- * expects never to extend).
- */
-struct buffer_head *ocfs2_bread(struct inode *inode,
-                                int block, int *err, int reada)
-{
-        struct buffer_head *bh = NULL;
-        int tmperr;
-        u64 p_blkno;
-        int readflags = OCFS2_BH_CACHED;
-        if (reada)
-                readflags |= OCFS2_BH_READAHEAD;
-        if (((u64)block << inode->i_sb->s_blocksize_bits) >=
-            i_size_read(inode)) {
-                BUG_ON(!reada);
-                return NULL;
-        }
-        down_read(&OCFS2_I(inode)->ip_alloc_sem);
-        tmperr = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
-                                             NULL);
-        up_read(&OCFS2_I(inode)->ip_alloc_sem);
-        if (tmperr < 0) {
-                mlog_errno(tmperr);
-                goto fail;
-        }
-        tmperr = ocfs2_read_block(OCFS2_SB(inode->i_sb), p_blkno, &bh,
-                                  readflags, inode);
-        if (tmperr < 0)
-                goto fail;
-        tmperr = 0;
-        *err = 0;
-        return bh;
-fail:
-        if (bh) {
-                brelse(bh);
-                bh = NULL;
-        }
-        *err = -EIO;
-        return NULL;
-}
-/*
 * This is called from our getattr.
 */
 int ocfs2_inode_revalidate(struct dentry *dentry)
diff --git a/fs/ocfs2/inode.h b/fs/ocfs2/inode.h
index 390a85596aa0..2f37af9bcc4a 100644
--- a/fs/ocfs2/inode.h
+++ b/fs/ocfs2/inode.h
@@ -40,6 +40,9 @@ struct ocfs2_inode_info
        /* protects allocation changes on this inode. */
        struct rw_semaphore             ip_alloc_sem;
+        /* protects extended attribute changes on this inode */
+        struct rw_semaphore             ip_xattr_sem;
        /* These fields are protected by ip_lock */
        spinlock_t                      ip_lock;
        u32                             ip_open_count;
@@ -68,6 +71,7 @@ struct ocfs2_inode_info
        struct ocfs2_extent_map         ip_extent_map;
        struct inode                    vfs_inode;
+        struct jbd2_inode               ip_jinode;
 };
 /*
@@ -113,8 +117,6 @@ extern struct kmem_cache *ocfs2_inode_cache;
 extern const struct address_space_operations ocfs2_aops;
-struct buffer_head *ocfs2_bread(struct inode *inode, int block,
-                                int *err, int reada);
 void ocfs2_clear_inode(struct inode *inode);
 void ocfs2_delete_inode(struct inode *inode);
 void ocfs2_drop_inode(struct inode *inode);
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index 7b142f0ce995..9fcd36dcc9a0 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -102,8 +102,7 @@ bail_unlock:
 bail:
        mutex_unlock(&inode->i_mutex);
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(status);
        return status;
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index c47bc2a809c2..81e40677eecb 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -215,9 +215,9 @@ static int ocfs2_commit_cache(struct ocfs2_super *osb)
                goto finally;
        }
-        journal_lock_updates(journal->j_journal);
+        jbd2_journal_lock_updates(journal->j_journal);
-        status = journal_flush(journal->j_journal);
+        status = jbd2_journal_flush(journal->j_journal);
-        journal_unlock_updates(journal->j_journal);
+        jbd2_journal_unlock_updates(journal->j_journal);
        if (status < 0) {
                up_write(&journal->j_trans_barrier);
                mlog_errno(status);
@@ -264,7 +264,7 @@ handle_t *ocfs2_start_trans(struct ocfs2_super *osb, int max_buffs)
        down_read(&osb->journal->j_trans_barrier);
-        handle = journal_start(journal, max_buffs);
+        handle = jbd2_journal_start(journal, max_buffs);
        if (IS_ERR(handle)) {
                up_read(&osb->journal->j_trans_barrier);
@@ -290,7 +290,7 @@ int ocfs2_commit_trans(struct ocfs2_super *osb,
        BUG_ON(!handle);
-        ret = journal_stop(handle);
+        ret = jbd2_journal_stop(handle);
        if (ret < 0)
                mlog_errno(ret);
@@ -304,7 +304,7 @@ int ocfs2_commit_trans(struct ocfs2_super *osb,
 * transaction. extend_trans will either extend the current handle by
 * nblocks, or commit it and start a new one with nblocks credits.
 *
- * This might call journal_restart() which will commit dirty buffers
+ * This might call jbd2_journal_restart() which will commit dirty buffers
 * and then restart the transaction. Before calling
 * ocfs2_extend_trans(), any changed blocks should have been
 * dirtied. After calling it, all blocks which need to be changed must
@@ -332,7 +332,7 @@ int ocfs2_extend_trans(handle_t *handle, int nblocks)
 #ifdef CONFIG_OCFS2_DEBUG_FS
        status = 1;
 #else
-        status = journal_extend(handle, nblocks);
+        status = jbd2_journal_extend(handle, nblocks);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -340,8 +340,10 @@ int ocfs2_extend_trans(handle_t *handle, int nblocks)
 #endif
        if (status > 0) {
-                mlog(0, "journal_extend failed, trying journal_restart\n");
+                mlog(0,
-                status = journal_restart(handle, nblocks);
+                     "jbd2_journal_extend failed, trying "
+                     "jbd2_journal_restart\n");
+                status = jbd2_journal_restart(handle, nblocks);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
@@ -393,11 +395,11 @@ int ocfs2_journal_access(handle_t *handle,
        switch (type) {
        case OCFS2_JOURNAL_ACCESS_CREATE:
        case OCFS2_JOURNAL_ACCESS_WRITE:
-                status = journal_get_write_access(handle, bh);
+                status = jbd2_journal_get_write_access(handle, bh);
                break;
        case OCFS2_JOURNAL_ACCESS_UNDO:
-                status = journal_get_undo_access(handle, bh);
+                status = jbd2_journal_get_undo_access(handle, bh);
                break;
        default:
@@ -422,7 +424,7 @@ int ocfs2_journal_dirty(handle_t *handle,
        mlog_entry("(bh->b_blocknr=%llu)\n",
                   (unsigned long long)bh->b_blocknr);
-        status = journal_dirty_metadata(handle, bh);
+        status = jbd2_journal_dirty_metadata(handle, bh);
        if (status < 0)
                mlog(ML_ERROR, "Could not dirty metadata buffer. "
                     "(bh->b_blocknr=%llu)\n",
@@ -432,6 +434,7 @@ int ocfs2_journal_dirty(handle_t *handle,
        return status;
 }
+#ifdef CONFIG_OCFS2_COMPAT_JBD
 int ocfs2_journal_dirty_data(handle_t *handle,
                             struct buffer_head *bh)
 {
@@ -443,8 +446,9 @@ int ocfs2_journal_dirty_data(handle_t *handle,
        return err;
 }
+#endif
-#define OCFS2_DEFAULT_COMMIT_INTERVAL   (HZ * JBD_DEFAULT_MAX_COMMIT_AGE)
+#define OCFS2_DEFAULT_COMMIT_INTERVAL   (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE)
 void ocfs2_set_journal_params(struct ocfs2_super *osb)
 {
@@ -457,9 +461,9 @@ void ocfs2_set_journal_params(struct ocfs2_super *osb)
        spin_lock(&journal->j_state_lock);
        journal->j_commit_interval = commit_interval;
        if (osb->s_mount_opt & OCFS2_MOUNT_BARRIER)
-                journal->j_flags |= JFS_BARRIER;
+                journal->j_flags |= JBD2_BARRIER;
        else
-                journal->j_flags &= ~JFS_BARRIER;
+                journal->j_flags &= ~JBD2_BARRIER;
        spin_unlock(&journal->j_state_lock);
 }
@@ -524,14 +528,14 @@ int ocfs2_journal_init(struct ocfs2_journal *journal, int *dirty)
        mlog(0, "inode->ip_clusters = %u\n", OCFS2_I(inode)->ip_clusters);
        /* call the kernels journal init function now */
-        j_journal = journal_init_inode(inode);
+        j_journal = jbd2_journal_init_inode(inode);
        if (j_journal == NULL) {
                mlog(ML_ERROR, "Linux journal layer error\n");
                status = -EINVAL;
                goto done;
        }
-        mlog(0, "Returned from journal_init_inode\n");
+        mlog(0, "Returned from jbd2_journal_init_inode\n");
        mlog(0, "j_journal->j_maxlen = %u\n", j_journal->j_maxlen);
        *dirty = (le32_to_cpu(di->id1.journal1.ij_flags) &
@@ -550,8 +554,7 @@ done:
        if (status < 0) {
                if (inode_lock)
                        ocfs2_inode_unlock(inode, 1);
-                if (bh != NULL)
+                brelse(bh);
-                        brelse(bh);
                if (inode) {
                        OCFS2_I(inode)->ip_open_count--;
                        iput(inode);
@@ -639,7 +642,7 @@ void ocfs2_journal_shutdown(struct ocfs2_super *osb)
        if (journal->j_state != OCFS2_JOURNAL_LOADED)
                goto done;
-        /* need to inc inode use count as journal_destroy will iput. */
+        /* need to inc inode use count - jbd2_journal_destroy will iput. */
        if (!igrab(inode))
                BUG();
@@ -668,9 +671,9 @@ void ocfs2_journal_shutdown(struct ocfs2_super *osb)
        BUG_ON(atomic_read(&(osb->journal->j_num_trans)) != 0);
        if (ocfs2_mount_local(osb)) {
-                journal_lock_updates(journal->j_journal);
+                jbd2_journal_lock_updates(journal->j_journal);
-                status = journal_flush(journal->j_journal);
+                status = jbd2_journal_flush(journal->j_journal);
-                journal_unlock_updates(journal->j_journal);
+                jbd2_journal_unlock_updates(journal->j_journal);
                if (status < 0)
                        mlog_errno(status);
        }
@@ -686,7 +689,7 @@ void ocfs2_journal_shutdown(struct ocfs2_super *osb)
        }
        /* Shutdown the kernel journal system */
-        journal_destroy(journal->j_journal);
+        jbd2_journal_destroy(journal->j_journal);
        OCFS2_I(inode)->ip_open_count--;
@@ -711,15 +714,15 @@ static void ocfs2_clear_journal_error(struct super_block *sb,
 {
        int olderr;
-        olderr = journal_errno(journal);
+        olderr = jbd2_journal_errno(journal);
        if (olderr) {
                mlog(ML_ERROR, "File system error %d recorded in "
                     "journal %u.\n", olderr, slot);
                mlog(ML_ERROR, "File system on device %s needs checking.\n",
                     sb->s_id);
-                journal_ack_err(journal);
+                jbd2_journal_ack_err(journal);
-                journal_clear_err(journal);
+                jbd2_journal_clear_err(journal);
        }
 }
@@ -734,7 +737,7 @@ int ocfs2_journal_load(struct ocfs2_journal *journal, int local, int replayed)
        osb = journal->j_osb;
-        status = journal_load(journal->j_journal);
+        status = jbd2_journal_load(journal->j_journal);
        if (status < 0) {
                mlog(ML_ERROR, "Failed to load journal!\n");
                goto done;
@@ -778,7 +781,7 @@ int ocfs2_journal_wipe(struct ocfs2_journal *journal, int full)
        BUG_ON(!journal);
-        status = journal_wipe(journal->j_journal, full);
+        status = jbd2_journal_wipe(journal->j_journal, full);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -847,9 +850,8 @@ static int ocfs2_force_read_journal(struct inode *inode)
                /* We are reading journal data which should not
                 * be put in the uptodate cache */
-                status = ocfs2_read_blocks(OCFS2_SB(inode->i_sb),
+                status = ocfs2_read_blocks_sync(OCFS2_SB(inode->i_sb),
-                                           p_blkno, p_blocks, bhs, 0,
+                                                p_blkno, p_blocks, bhs);
-                                           NULL);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
@@ -865,8 +867,7 @@ static int ocfs2_force_read_journal(struct inode *inode)
 bail:
        for(i = 0; i < CONCURRENT_JOURNAL_FILL; i++)
-                if (bhs[i])
+                brelse(bhs[i]);
-                        brelse(bhs[i]);
        mlog_exit(status);
        return status;
 }
@@ -1133,7 +1134,8 @@ static int ocfs2_read_journal_inode(struct ocfs2_super *osb,
        }
        SET_INODE_JOURNAL(inode);
-        status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, bh, 0, inode);
+        status = ocfs2_read_blocks(inode, OCFS2_I(inode)->ip_blkno, 1, bh,
+                                   OCFS2_BH_IGNORE_CACHE);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -1229,19 +1231,19 @@ static int ocfs2_replay_journal(struct ocfs2_super *osb,
        }
        mlog(0, "calling journal_init_inode\n");
-        journal = journal_init_inode(inode);
+        journal = jbd2_journal_init_inode(inode);
        if (journal == NULL) {
                mlog(ML_ERROR, "Linux journal layer error\n");
                status = -EIO;
                goto done;
        }
-        status = journal_load(journal);
+        status = jbd2_journal_load(journal);
        if (status < 0) {
                mlog_errno(status);
                if (!igrab(inode))
                        BUG();
-                journal_destroy(journal);
+                jbd2_journal_destroy(journal);
                goto done;
        }
@@ -1249,9 +1251,9 @@ static int ocfs2_replay_journal(struct ocfs2_super *osb,
        /* wipe the journal */
        mlog(0, "flushing the journal.\n");
-        journal_lock_updates(journal);
+        jbd2_journal_lock_updates(journal);
-        status = journal_flush(journal);
+        status = jbd2_journal_flush(journal);
-        journal_unlock_updates(journal);
+        jbd2_journal_unlock_updates(journal);
        if (status < 0)
                mlog_errno(status);
@@ -1272,7 +1274,7 @@ static int ocfs2_replay_journal(struct ocfs2_super *osb,
        if (!igrab(inode))
                BUG();
-        journal_destroy(journal);
+        jbd2_journal_destroy(journal);
 done:
        /* drop the lock on this nodes journal */
@@ -1282,8 +1284,7 @@ done:
        if (inode)
                iput(inode);
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(status);
        return status;
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 2178ebffa05f..d4d14e9a3cea 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -27,7 +27,12 @@
 #define OCFS2_JOURNAL_H
 #include <linux/fs.h>
-#include <linux/jbd.h>
+#ifndef CONFIG_OCFS2_COMPAT_JBD
+# include <linux/jbd2.h>
+#else
+# include <linux/jbd.h>
+# include "ocfs2_jbd_compat.h"
+#endif
 enum ocfs2_journal_state {
        OCFS2_JOURNAL_FREE = 0,
@@ -215,8 +220,8 @@ static inline void ocfs2_checkpoint_inode(struct inode *inode)
 *                          buffer. Will have to call ocfs2_journal_dirty once
 *                          we've actually dirtied it. Type is one of . or .
 *  ocfs2_journal_dirty    - Mark a journalled buffer as having dirty data.
- *  ocfs2_journal_dirty_data - Indicate that a data buffer should go out before
+ *  ocfs2_jbd2_file_inode  - Mark an inode so that its data goes out before
- *                             the current handle commits.
+ *                           the current handle commits.
 */
 /* You must always start_trans with a number of buffs > 0, but it's
@@ -268,8 +273,10 @@ int                  ocfs2_journal_access(handle_t *handle,
 */
 int                  ocfs2_journal_dirty(handle_t *handle,
                                         struct buffer_head *bh);
+#ifdef CONFIG_OCFS2_COMPAT_JBD
 int                  ocfs2_journal_dirty_data(handle_t *handle,
                                              struct buffer_head *bh);
+#endif
 /*
 *  Credit Macros:
@@ -283,6 +290,9 @@ int                  ocfs2_journal_dirty_data(handle_t *handle,
 /* simple file updates like chmod, etc. */
 #define OCFS2_INODE_UPDATE_CREDITS 1
+/* extended attribute block update */
+#define OCFS2_XATTR_BLOCK_UPDATE_CREDITS 1
 /* group extend. inode update and last group update. */
 #define OCFS2_GROUP_EXTEND_CREDITS      (OCFS2_INODE_UPDATE_CREDITS + 1)
@@ -340,11 +350,23 @@ int                  ocfs2_journal_dirty_data(handle_t *handle,
 #define OCFS2_RENAME_CREDITS (3 * OCFS2_INODE_UPDATE_CREDITS + 3              \
                             + OCFS2_UNLINK_CREDITS)
+/* global bitmap dinode, group desc., relinked group,
+ * suballocator dinode, group desc., relinked group,
+ * dinode, xattr block */
+#define OCFS2_XATTR_BLOCK_CREATE_CREDITS (OCFS2_SUBALLOC_ALLOC * 2 + \
+                                          + OCFS2_INODE_UPDATE_CREDITS \
+                                          + OCFS2_XATTR_BLOCK_UPDATE_CREDITS)
+/*
+ * Please note that the caller must make sure that root_el is the root
+ * of extent tree. So for an inode, it should be &fe->id2.i_list. Otherwise
+ * the result may be wrong.
+ */
 static inline int ocfs2_calc_extend_credits(struct super_block *sb,
-                                            struct ocfs2_dinode *fe,
+                                            struct ocfs2_extent_list *root_el,
                                            u32 bits_wanted)
 {
-        int bitmap_blocks, sysfile_bitmap_blocks, dinode_blocks;
+        int bitmap_blocks, sysfile_bitmap_blocks, extent_blocks;
        /* bitmap dinode, group desc. + relinked group. */
        bitmap_blocks = OCFS2_SUBALLOC_ALLOC;
@@ -355,16 +377,16 @@ static inline int ocfs2_calc_extend_credits(struct super_block *sb,
         * however many metadata chunks needed * a remaining suballoc
         * alloc. */
        sysfile_bitmap_blocks = 1 +
-                (OCFS2_SUBALLOC_ALLOC - 1) * ocfs2_extend_meta_needed(fe);
+                (OCFS2_SUBALLOC_ALLOC - 1) * ocfs2_extend_meta_needed(root_el);
        /* this does not include *new* metadata blocks, which are
-         * accounted for in sysfile_bitmap_blocks. fe +
+         * accounted for in sysfile_bitmap_blocks. root_el +
         * prev. last_eb_blk + blocks along edge of tree.
         * calc_symlink_credits passes because we just need 1
         * credit for the dinode there. */
-        dinode_blocks = 1 + 1 + le16_to_cpu(fe->id2.i_list.l_tree_depth);
+        extent_blocks = 1 + 1 + le16_to_cpu(root_el->l_tree_depth);
-        return bitmap_blocks + sysfile_bitmap_blocks + dinode_blocks;
+        return bitmap_blocks + sysfile_bitmap_blocks + extent_blocks;
 }
 static inline int ocfs2_calc_symlink_credits(struct super_block *sb)
@@ -415,4 +437,16 @@ static inline int ocfs2_calc_tree_trunc_credits(struct super_block *sb,
        return credits;
 }
+static inline int ocfs2_jbd2_file_inode(handle_t *handle, struct inode *inode)
+{
+        return jbd2_journal_file_inode(handle, &OCFS2_I(inode)->ip_jinode);
+}
+static inline int ocfs2_begin_ordered_truncate(struct inode *inode,
+                                               loff_t new_size)
+{
+        return jbd2_journal_begin_ordered_truncate(&OCFS2_I(inode)->ip_jinode,
+                                                   new_size);
+}
 #endif /* OCFS2_JOURNAL_H */
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index 28e492e4ec88..687b28713c32 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -28,6 +28,7 @@
 #include <linux/slab.h>
 #include <linux/highmem.h>
 #include <linux/bitops.h>
+#include <linux/debugfs.h>
 #define MLOG_MASK_PREFIX ML_DISK_ALLOC
 #include <cluster/masklog.h>
@@ -47,8 +48,6 @@
 #define OCFS2_LOCAL_ALLOC(dinode)       (&((dinode)->id2.i_lab))
-static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb);
 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc);
 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
@@ -75,24 +74,129 @@ static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
                                          struct inode *local_alloc_inode);
-static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb)
+#ifdef CONFIG_OCFS2_FS_STATS
+static int ocfs2_la_debug_open(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+#define LA_DEBUG_BUF_SZ PAGE_CACHE_SIZE
+#define LA_DEBUG_VER    1
+static ssize_t ocfs2_la_debug_read(struct file *file, char __user *userbuf,
+                                   size_t count, loff_t *ppos)
+{
+        static DEFINE_MUTEX(la_debug_mutex);
+        struct ocfs2_super *osb = file->private_data;
+        int written, ret;
+        char *buf = osb->local_alloc_debug_buf;
+        mutex_lock(&la_debug_mutex);
+        memset(buf, 0, LA_DEBUG_BUF_SZ);
+        written = snprintf(buf, LA_DEBUG_BUF_SZ,
+                           "0x%x\t0x%llx\t%u\t%u\t0x%x\n",
+                           LA_DEBUG_VER,
+                           (unsigned long long)osb->la_last_gd,
+                           osb->local_alloc_default_bits,
+                           osb->local_alloc_bits, osb->local_alloc_state);
+        ret = simple_read_from_buffer(userbuf, count, ppos, buf, written);
+        mutex_unlock(&la_debug_mutex);
+        return ret;
+}
+static const struct file_operations ocfs2_la_debug_fops = {
+        .open =         ocfs2_la_debug_open,
+        .read =         ocfs2_la_debug_read,
+};
+static void ocfs2_init_la_debug(struct ocfs2_super *osb)
+{
+        osb->local_alloc_debug_buf = kmalloc(LA_DEBUG_BUF_SZ, GFP_NOFS);
+        if (!osb->local_alloc_debug_buf)
+                return;
+        osb->local_alloc_debug = debugfs_create_file("local_alloc_stats",
+                                                     S_IFREG|S_IRUSR,
+                                                     osb->osb_debug_root,
+                                                     osb,
+                                                     &ocfs2_la_debug_fops);
+        if (!osb->local_alloc_debug) {
+                kfree(osb->local_alloc_debug_buf);
+                osb->local_alloc_debug_buf = NULL;
+        }
+}
+static void ocfs2_shutdown_la_debug(struct ocfs2_super *osb)
+{
+        if (osb->local_alloc_debug)
+                debugfs_remove(osb->local_alloc_debug);
+        if (osb->local_alloc_debug_buf)
+                kfree(osb->local_alloc_debug_buf);
+        osb->local_alloc_debug_buf = NULL;
+        osb->local_alloc_debug = NULL;
+}
+#else   /* CONFIG_OCFS2_FS_STATS */
+static void ocfs2_init_la_debug(struct ocfs2_super *osb)
+{
+        return;
+}
+static void ocfs2_shutdown_la_debug(struct ocfs2_super *osb)
+{
+        return;
+}
+#endif
+static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb)
 {
-        BUG_ON(osb->s_clustersize_bits > 20);
+        return (osb->local_alloc_state == OCFS2_LA_THROTTLED ||
+                osb->local_alloc_state == OCFS2_LA_ENABLED);
+}
-        /* Size local alloc windows by the megabyte */
+void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
-        return osb->local_alloc_size << (20 - osb->s_clustersize_bits);
+                                      unsigned int num_clusters)
+{
+        spin_lock(&osb->osb_lock);
+        if (osb->local_alloc_state == OCFS2_LA_DISABLED ||
+            osb->local_alloc_state == OCFS2_LA_THROTTLED)
+                if (num_clusters >= osb->local_alloc_default_bits) {
+                        cancel_delayed_work(&osb->la_enable_wq);
+                        osb->local_alloc_state = OCFS2_LA_ENABLED;
+                }
+        spin_unlock(&osb->osb_lock);
+}
+void ocfs2_la_enable_worker(struct work_struct *work)
+{
+        struct ocfs2_super *osb =
+                container_of(work, struct ocfs2_super,
+                             la_enable_wq.work);
+        spin_lock(&osb->osb_lock);
+        osb->local_alloc_state = OCFS2_LA_ENABLED;
+        spin_unlock(&osb->osb_lock);
 }
 /*
 * Tell us whether a given allocation should use the local alloc
 * file. Otherwise, it has to go to the main bitmap.
+ *
+ * This function does semi-dirty reads of local alloc size and state!
+ * This is ok however, as the values are re-checked once under mutex.
 */
 int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
 {
-        int la_bits = ocfs2_local_alloc_window_bits(osb);
        int ret = 0;
+        int la_bits;
+        spin_lock(&osb->osb_lock);
+        la_bits = osb->local_alloc_bits;
-        if (osb->local_alloc_state != OCFS2_LA_ENABLED)
+        if (!ocfs2_la_state_enabled(osb))
                goto bail;
        /* la_bits should be at least twice the size (in clusters) of
@@ -106,6 +210,7 @@ int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
 bail:
        mlog(0, "state=%d, bits=%llu, la_bits=%d, ret=%d\n",
             osb->local_alloc_state, (unsigned long long)bits, la_bits, ret);
+        spin_unlock(&osb->osb_lock);
        return ret;
 }
@@ -120,14 +225,18 @@ int ocfs2_load_local_alloc(struct ocfs2_super *osb)
        mlog_entry_void();
-        if (osb->local_alloc_size == 0)
+        ocfs2_init_la_debug(osb);
+        if (osb->local_alloc_bits == 0)
                goto bail;
-        if (ocfs2_local_alloc_window_bits(osb) >= osb->bitmap_cpg) {
+        if (osb->local_alloc_bits >= osb->bitmap_cpg) {
                mlog(ML_NOTICE, "Requested local alloc window %d is larger "
                     "than max possible %u. Using defaults.\n",
-                     ocfs2_local_alloc_window_bits(osb), (osb->bitmap_cpg - 1));
+                     osb->local_alloc_bits, (osb->bitmap_cpg - 1));
-                osb->local_alloc_size = OCFS2_DEFAULT_LOCAL_ALLOC_SIZE;
+                osb->local_alloc_bits =
+                        ocfs2_megabytes_to_clusters(osb->sb,
+                                                    OCFS2_DEFAULT_LOCAL_ALLOC_SIZE);
        }
        /* read the alloc off disk */
@@ -139,8 +248,8 @@ int ocfs2_load_local_alloc(struct ocfs2_super *osb)
                goto bail;
        }
-        status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno,
+        status = ocfs2_read_blocks(inode, OCFS2_I(inode)->ip_blkno, 1,
-                                  &alloc_bh, 0, inode);
+                                   &alloc_bh, OCFS2_BH_IGNORE_CACHE);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -185,13 +294,14 @@ int ocfs2_load_local_alloc(struct ocfs2_super *osb)
 bail:
        if (status < 0)
-                if (alloc_bh)
+                brelse(alloc_bh);
-                        brelse(alloc_bh);
        if (inode)
                iput(inode);
-        mlog(0, "Local alloc window bits = %d\n",
+        if (status < 0)
-             ocfs2_local_alloc_window_bits(osb));
+                ocfs2_shutdown_la_debug(osb);
+        mlog(0, "Local alloc window bits = %d\n", osb->local_alloc_bits);
        mlog_exit(status);
        return status;
@@ -217,6 +327,11 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
        mlog_entry_void();
+        cancel_delayed_work(&osb->la_enable_wq);
+        flush_workqueue(ocfs2_wq);
+        ocfs2_shutdown_la_debug(osb);
        if (osb->local_alloc_state == OCFS2_LA_UNUSED)
                goto out;
@@ -295,8 +410,7 @@ out_commit:
        ocfs2_commit_trans(osb, handle);
 out_unlock:
-        if (main_bm_bh)
+        brelse(main_bm_bh);
-                brelse(main_bm_bh);
        ocfs2_inode_unlock(main_bm_inode, 1);
@@ -345,8 +459,8 @@ int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,
        mutex_lock(&inode->i_mutex);
-        status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno,
+        status = ocfs2_read_blocks(inode, OCFS2_I(inode)->ip_blkno, 1,
-                                  &alloc_bh, 0, inode);
+                                   &alloc_bh, OCFS2_BH_IGNORE_CACHE);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -372,8 +486,7 @@ bail:
                *alloc_copy = NULL;
        }
-        if (alloc_bh)
+        brelse(alloc_bh);
-                brelse(alloc_bh);
        if (inode) {
                mutex_unlock(&inode->i_mutex);
@@ -441,8 +554,7 @@ out_unlock:
 out_mutex:
        mutex_unlock(&main_bm_inode->i_mutex);
-        if (main_bm_bh)
+        brelse(main_bm_bh);
-                brelse(main_bm_bh);
        iput(main_bm_inode);
@@ -453,8 +565,48 @@ out:
        return status;
 }
+/* Check to see if the local alloc window is within ac->ac_max_block */
+static int ocfs2_local_alloc_in_range(struct inode *inode,
+                                      struct ocfs2_alloc_context *ac,
+                                      u32 bits_wanted)
+{
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_dinode *alloc;
+        struct ocfs2_local_alloc *la;
+        int start;
+        u64 block_off;
+        if (!ac->ac_max_block)
+                return 1;
+        alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
+        la = OCFS2_LOCAL_ALLOC(alloc);
+        start = ocfs2_local_alloc_find_clear_bits(osb, alloc, bits_wanted);
+        if (start == -1) {
+                mlog_errno(-ENOSPC);
+                return 0;
+        }
+        /*
+         * Converting (bm_off + start + bits_wanted) to blocks gives us
+         * the blkno just past our actual allocation.  This is perfect
+         * to compare with ac_max_block.
+         */
+        block_off = ocfs2_clusters_to_blocks(inode->i_sb,
+                                             le32_to_cpu(la->la_bm_off) +
+                                             start + bits_wanted);
+        mlog(0, "Checking %llu against %llu\n",
+             (unsigned long long)block_off,
+             (unsigned long long)ac->ac_max_block);
+        if (block_off > ac->ac_max_block)
+                return 0;
+        return 1;
+}
 /*
- * make sure we've got at least bitswanted contiguous bits in the
+ * make sure we've got at least bits_wanted contiguous bits in the
 * local alloc. You lose them when you drop i_mutex.
 *
 * We will add ourselves to the transaction passed in, but may start
@@ -485,16 +637,18 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
        mutex_lock(&local_alloc_inode->i_mutex);
-        if (osb->local_alloc_state != OCFS2_LA_ENABLED) {
+        /*
-                status = -ENOSPC;
+         * We must double check state and allocator bits because
-                goto bail;
+         * another process may have changed them while holding i_mutex.
-        }
+         */
+        spin_lock(&osb->osb_lock);
-        if (bits_wanted > ocfs2_local_alloc_window_bits(osb)) {
+        if (!ocfs2_la_state_enabled(osb) ||
-                mlog(0, "Asking for more than my max window size!\n");
+            (bits_wanted > osb->local_alloc_bits)) {
+                spin_unlock(&osb->osb_lock);
                status = -ENOSPC;
                goto bail;
        }
+        spin_unlock(&osb->osb_lock);
        alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
@@ -522,6 +676,36 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
                                mlog_errno(status);
                        goto bail;
                }
+                /*
+                 * Under certain conditions, the window slide code
+                 * might have reduced the number of bits available or
+                 * disabled the the local alloc entirely. Re-check
+                 * here and return -ENOSPC if necessary.
+                 */
+                status = -ENOSPC;
+                if (!ocfs2_la_state_enabled(osb))
+                        goto bail;
+                free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
+                        le32_to_cpu(alloc->id1.bitmap1.i_used);
+                if (bits_wanted > free_bits)
+                        goto bail;
+        }
+        if (ac->ac_max_block)
+                mlog(0, "Calling in_range for max block %llu\n",
+                     (unsigned long long)ac->ac_max_block);
+        if (!ocfs2_local_alloc_in_range(local_alloc_inode, ac,
+                                        bits_wanted)) {
+                /*
+                 * The window is outside ac->ac_max_block.
+                 * This errno tells the caller to keep localalloc enabled
+                 * but to get the allocation from the main bitmap.
+                 */
+                status = -EFBIG;
+                goto bail;
        }
        ac->ac_inode = local_alloc_inode;
@@ -789,6 +973,85 @@ bail:
        return status;
 }
+enum ocfs2_la_event {
+        OCFS2_LA_EVENT_SLIDE,           /* Normal window slide. */
+        OCFS2_LA_EVENT_FRAGMENTED,      /* The global bitmap has
+                                         * enough bits theoretically
+                                         * free, but a contiguous
+                                         * allocation could not be
+                                         * found. */
+        OCFS2_LA_EVENT_ENOSPC,          /* Global bitmap doesn't have
+                                         * enough bits free to satisfy
+                                         * our request. */
+};
+#define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
+/*
+ * Given an event, calculate the size of our next local alloc window.
+ *
+ * This should always be called under i_mutex of the local alloc inode
+ * so that local alloc disabling doesn't race with processes trying to
+ * use the allocator.
+ *
+ * Returns the state which the local alloc was left in. This value can
+ * be ignored by some paths.
+ */
+static int ocfs2_recalc_la_window(struct ocfs2_super *osb,
+                                  enum ocfs2_la_event event)
+{
+        unsigned int bits;
+        int state;
+        spin_lock(&osb->osb_lock);
+        if (osb->local_alloc_state == OCFS2_LA_DISABLED) {
+                WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED);
+                goto out_unlock;
+        }
+        /*
+         * ENOSPC and fragmentation are treated similarly for now.
+         */
+        if (event == OCFS2_LA_EVENT_ENOSPC ||
+            event == OCFS2_LA_EVENT_FRAGMENTED) {
+                /*
+                 * We ran out of contiguous space in the primary
+                 * bitmap. Drastically reduce the number of bits used
+                 * by local alloc until we have to disable it.
+                 */
+                bits = osb->local_alloc_bits >> 1;
+                if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) {
+                        /*
+                         * By setting state to THROTTLED, we'll keep
+                         * the number of local alloc bits used down
+                         * until an event occurs which would give us
+                         * reason to assume the bitmap situation might
+                         * have changed.
+                         */
+                        osb->local_alloc_state = OCFS2_LA_THROTTLED;
+                        osb->local_alloc_bits = bits;
+                } else {
+                        osb->local_alloc_state = OCFS2_LA_DISABLED;
+                }
+                queue_delayed_work(ocfs2_wq, &osb->la_enable_wq,
+                                   OCFS2_LA_ENABLE_INTERVAL);
+                goto out_unlock;
+        }
+        /*
+         * Don't increase the size of the local alloc window until we
+         * know we might be able to fulfill the request. Otherwise, we
+         * risk bouncing around the global bitmap during periods of
+         * low space.
+         */
+        if (osb->local_alloc_state != OCFS2_LA_THROTTLED)
+                osb->local_alloc_bits = osb->local_alloc_default_bits;
+out_unlock:
+        state = osb->local_alloc_state;
+        spin_unlock(&osb->osb_lock);
+        return state;
+}
 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
                                                struct ocfs2_alloc_context **ac,
                                                struct inode **bitmap_inode,
@@ -803,12 +1066,21 @@ static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
                goto bail;
        }
-        (*ac)->ac_bits_wanted = ocfs2_local_alloc_window_bits(osb);
+retry_enospc:
+        (*ac)->ac_bits_wanted = osb->local_alloc_bits;
        status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
+        if (status == -ENOSPC) {
+                if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) ==
+                    OCFS2_LA_DISABLED)
+                        goto bail;
+                ocfs2_free_ac_resource(*ac);
+                memset(*ac, 0, sizeof(struct ocfs2_alloc_context));
+                goto retry_enospc;
+        }
        if (status < 0) {
-                if (status != -ENOSPC)
+                mlog_errno(status);
-                        mlog_errno(status);
                goto bail;
        }
@@ -849,7 +1121,7 @@ static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
                     "one\n");
        mlog(0, "Allocating %u clusters for a new window.\n",
-             ocfs2_local_alloc_window_bits(osb));
+             osb->local_alloc_bits);
        /* Instruct the allocation code to try the most recently used
         * cluster group. We'll re-record the group used this pass
@@ -859,9 +1131,36 @@ static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
        /* we used the generic suballoc reserve function, but we set
         * everything up nicely, so there's no reason why we can't use
         * the more specific cluster api to claim bits. */
-        status = ocfs2_claim_clusters(osb, handle, ac,
+        status = ocfs2_claim_clusters(osb, handle, ac, osb->local_alloc_bits,
-                                      ocfs2_local_alloc_window_bits(osb),
                                      &cluster_off, &cluster_count);
+        if (status == -ENOSPC) {
+retry_enospc:
+                /*
+                 * Note: We could also try syncing the journal here to
+                 * allow use of any free bits which the current
+                 * transaction can't give us access to. --Mark
+                 */
+                if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) ==
+                    OCFS2_LA_DISABLED)
+                        goto bail;
+                status = ocfs2_claim_clusters(osb, handle, ac,
+                                              osb->local_alloc_bits,
+                                              &cluster_off,
+                                              &cluster_count);
+                if (status == -ENOSPC)
+                        goto retry_enospc;
+                /*
+                 * We only shrunk the *minimum* number of in our
+                 * request - it's entirely possible that the allocator
+                 * might give us more than we asked for.
+                 */
+                if (status == 0) {
+                        spin_lock(&osb->osb_lock);
+                        osb->local_alloc_bits = cluster_count;
+                        spin_unlock(&osb->osb_lock);
+                }
+        }
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -905,6 +1204,8 @@ static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
        mlog_entry_void();
+        ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE);
        /* This will lock the main bitmap for us. */
        status = ocfs2_local_alloc_reserve_for_window(osb,
                                                      &ac,
@@ -976,8 +1277,7 @@ bail:
        if (handle)
                ocfs2_commit_trans(osb, handle);
-        if (main_bm_bh)
+        brelse(main_bm_bh);
-                brelse(main_bm_bh);
        if (main_bm_inode)
                iput(main_bm_inode);
diff --git a/fs/ocfs2/localalloc.h b/fs/ocfs2/localalloc.h
index 3f76631e110c..ac5ea9f86653 100644
--- a/fs/ocfs2/localalloc.h
+++ b/fs/ocfs2/localalloc.h
@@ -52,4 +52,8 @@ int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
                                 u32 *bit_off,
                                 u32 *num_bits);
+void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
+                                      unsigned int num_clusters);
+void ocfs2_la_enable_worker(struct work_struct *work);
 #endif /* OCFS2_LOCALALLOC_H */
diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c
index 203f87143877..544ac6245175 100644
--- a/fs/ocfs2/locks.c
+++ b/fs/ocfs2/locks.c
@@ -24,6 +24,7 @@
 */
 #include <linux/fs.h>
+#include <linux/fcntl.h>
 #define MLOG_MASK_PREFIX ML_INODE
 #include <cluster/masklog.h>
@@ -32,6 +33,7 @@
 #include "dlmglue.h"
 #include "file.h"
+#include "inode.h"
 #include "locks.h"
 static int ocfs2_do_flock(struct file *file, struct inode *inode,
@@ -123,3 +125,16 @@ int ocfs2_flock(struct file *file, int cmd, struct file_lock *fl)
        else
                return ocfs2_do_flock(file, inode, cmd, fl);
 }
+int ocfs2_lock(struct file *file, int cmd, struct file_lock *fl)
+{
+        struct inode *inode = file->f_mapping->host;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        if (!(fl->fl_flags & FL_POSIX))
+                return -ENOLCK;
+        if (__mandatory_lock(inode))
+                return -ENOLCK;
+        return ocfs2_plock(osb->cconn, OCFS2_I(inode)->ip_blkno, file, cmd, fl);
+}
diff --git a/fs/ocfs2/locks.h b/fs/ocfs2/locks.h
index 9743ef2324ec..496d488b271f 100644
--- a/fs/ocfs2/locks.h
+++ b/fs/ocfs2/locks.h
@@ -27,5 +27,6 @@
 #define OCFS2_LOCKS_H
 int ocfs2_flock(struct file *file, int cmd, struct file_lock *fl);
+int ocfs2_lock(struct file *file, int cmd, struct file_lock *fl);
 #endif /* OCFS2_LOCKS_H */
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index d5d808fe0140..485a6aa0ad39 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -60,6 +60,7 @@
 #include "symlink.h"
 #include "sysfile.h"
 #include "uptodate.h"
+#include "xattr.h"
 #include "buffer_head_io.h"
@@ -327,14 +328,9 @@ leave:
        if (status == -ENOSPC)
                mlog(0, "Disk is full\n");
-        if (new_fe_bh)
+        brelse(new_fe_bh);
-                brelse(new_fe_bh);
+        brelse(de_bh);
+        brelse(parent_fe_bh);
-        if (de_bh)
-                brelse(de_bh);
-        if (parent_fe_bh)
-                brelse(parent_fe_bh);
        if ((status < 0) && inode)
                iput(inode);
@@ -647,12 +643,9 @@ out_unlock_inode:
 out:
        ocfs2_inode_unlock(dir, 1);
-        if (de_bh)
+        brelse(de_bh);
-                brelse(de_bh);
+        brelse(fe_bh);
-        if (fe_bh)
+        brelse(parent_fe_bh);
-                brelse(fe_bh);
-        if (parent_fe_bh)
-                brelse(parent_fe_bh);
        mlog_exit(err);
@@ -851,17 +844,10 @@ leave:
                iput(orphan_dir);
        }
-        if (fe_bh)
+        brelse(fe_bh);
-                brelse(fe_bh);
+        brelse(dirent_bh);
+        brelse(parent_node_bh);
-        if (dirent_bh)
+        brelse(orphan_entry_bh);
-                brelse(dirent_bh);
-        if (parent_node_bh)
-                brelse(parent_node_bh);
-        if (orphan_entry_bh)
-                brelse(orphan_entry_bh);
        mlog_exit(status);
@@ -1372,24 +1358,15 @@ bail:
        if (new_inode)
                iput(new_inode);
-        if (newfe_bh)
+        brelse(newfe_bh);
-                brelse(newfe_bh);
+        brelse(old_inode_bh);
-        if (old_inode_bh)
+        brelse(old_dir_bh);
-                brelse(old_inode_bh);
+        brelse(new_dir_bh);
-        if (old_dir_bh)
+        brelse(new_de_bh);
-                brelse(old_dir_bh);
+        brelse(old_de_bh);
-        if (new_dir_bh)
+        brelse(old_inode_de_bh);
-                brelse(new_dir_bh);
+        brelse(orphan_entry_bh);
-        if (new_de_bh)
+        brelse(insert_entry_bh);
-                brelse(new_de_bh);
-        if (old_de_bh)
-                brelse(old_de_bh);
-        if (old_inode_de_bh)
-                brelse(old_inode_de_bh);
-        if (orphan_entry_bh)
-                brelse(orphan_entry_bh);
-        if (insert_entry_bh)
-                brelse(insert_entry_bh);
        mlog_exit(status);
@@ -1492,8 +1469,7 @@ bail:
        if (bhs) {
                for(i = 0; i < blocks; i++)
-                        if (bhs[i])
+                        brelse(bhs[i]);
-                                brelse(bhs[i]);
                kfree(bhs);
        }
@@ -1598,10 +1574,10 @@ static int ocfs2_symlink(struct inode *dir,
                u32 offset = 0;
                inode->i_op = &ocfs2_symlink_inode_operations;
-                status = ocfs2_do_extend_allocation(osb, inode, &offset, 1, 0,
+                status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
-                                                    new_fe_bh,
+                                              new_fe_bh,
-                                                    handle, data_ac, NULL,
+                                              handle, data_ac, NULL,
-                                                    NULL);
+                                              NULL);
                if (status < 0) {
                        if (status != -ENOSPC && status != -EINTR) {
                                mlog(ML_ERROR,
@@ -1659,12 +1635,9 @@ bail:
        ocfs2_inode_unlock(dir, 1);
-        if (new_fe_bh)
+        brelse(new_fe_bh);
-                brelse(new_fe_bh);
+        brelse(parent_fe_bh);
-        if (parent_fe_bh)
+        brelse(de_bh);
-                brelse(parent_fe_bh);
-        if (de_bh)
-                brelse(de_bh);
        if (inode_ac)
                ocfs2_free_alloc_context(inode_ac);
        if (data_ac)
@@ -1759,8 +1732,7 @@ leave:
                iput(orphan_dir_inode);
        }
-        if (orphan_dir_bh)
+        brelse(orphan_dir_bh);
-                brelse(orphan_dir_bh);
        mlog_exit(status);
        return status;
@@ -1780,10 +1752,9 @@ static int ocfs2_orphan_add(struct ocfs2_super *osb,
        mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
-        status = ocfs2_read_block(osb,
+        status = ocfs2_read_block(orphan_dir_inode,
                                  OCFS2_I(orphan_dir_inode)->ip_blkno,
-                                  &orphan_dir_bh, OCFS2_BH_CACHED,
+                                  &orphan_dir_bh);
-                                  orphan_dir_inode);
        if (status < 0) {
                mlog_errno(status);
                goto leave;
@@ -1829,8 +1800,7 @@ static int ocfs2_orphan_add(struct ocfs2_super *osb,
             (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
 leave:
-        if (orphan_dir_bh)
+        brelse(orphan_dir_bh);
-                brelse(orphan_dir_bh);
        mlog_exit(status);
        return status;
@@ -1898,8 +1868,7 @@ int ocfs2_orphan_del(struct ocfs2_super *osb,
        }
 leave:
-        if (target_de_bh)
+        brelse(target_de_bh);
-                brelse(target_de_bh);
        mlog_exit(status);
        return status;
@@ -1918,4 +1887,8 @@ const struct inode_operations ocfs2_dir_iops = {
        .setattr        = ocfs2_setattr,
        .getattr        = ocfs2_getattr,
        .permission     = ocfs2_permission,
+        .setxattr       = generic_setxattr,
+        .getxattr       = generic_getxattr,
+        .listxattr      = ocfs2_listxattr,
+        .removexattr    = generic_removexattr,
 };
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index 7f625f2b1117..a21a465490c4 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -34,7 +34,12 @@
 #include <linux/workqueue.h>
 #include <linux/kref.h>
 #include <linux/mutex.h>
-#include <linux/jbd.h>
+#ifndef CONFIG_OCFS2_COMPAT_JBD
+# include <linux/jbd2.h>
+#else
+# include <linux/jbd.h>
+# include "ocfs2_jbd_compat.h"
+#endif
 /* For union ocfs2_dlm_lksb */
 #include "stackglue.h"
@@ -171,9 +176,13 @@ struct ocfs2_alloc_stats
 enum ocfs2_local_alloc_state
 {
-        OCFS2_LA_UNUSED = 0,
+        OCFS2_LA_UNUSED = 0,    /* Local alloc will never be used for
-        OCFS2_LA_ENABLED,
+                                 * this mountpoint. */
-        OCFS2_LA_DISABLED
+        OCFS2_LA_ENABLED,       /* Local alloc is in use. */
+        OCFS2_LA_THROTTLED,     /* Local alloc is in use, but number
+                                 * of bits has been reduced. */
+        OCFS2_LA_DISABLED       /* Local alloc has temporarily been
+                                 * disabled. */
 };
 enum ocfs2_mount_options
@@ -184,6 +193,8 @@ enum ocfs2_mount_options
        OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */
        OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */
        OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */
+        OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */
+        OCFS2_MOUNT_INODE64 = 1 << 7,   /* Allow inode numbers > 2^32 */
 };
 #define OCFS2_OSB_SOFT_RO       0x0001
@@ -214,6 +225,7 @@ struct ocfs2_super
        u32 bitmap_cpg;
        u8 *uuid;
        char *uuid_str;
+        u32 uuid_hash;
        u8 *vol_label;
        u64 first_cluster_group_blkno;
        u32 fs_generation;
@@ -241,6 +253,7 @@ struct ocfs2_super
        int s_sectsize_bits;
        int s_clustersize;
        int s_clustersize_bits;
+        unsigned int s_xattr_inline_size;
        atomic_t vol_state;
        struct mutex recovery_lock;
@@ -252,11 +265,27 @@ struct ocfs2_super
        struct ocfs2_journal *journal;
        unsigned long osb_commit_interval;
-        int local_alloc_size;
+        struct delayed_work             la_enable_wq;
-        enum ocfs2_local_alloc_state local_alloc_state;
+        /*
+         * Must hold local alloc i_mutex and osb->osb_lock to change
+         * local_alloc_bits. Reads can be done under either lock.
+         */
+        unsigned int local_alloc_bits;
+        unsigned int local_alloc_default_bits;
+        enum ocfs2_local_alloc_state local_alloc_state; /* protected
+                                                         * by osb_lock */
        struct buffer_head *local_alloc_bh;
        u64 la_last_gd;
+#ifdef CONFIG_OCFS2_FS_STATS
+        struct dentry *local_alloc_debug;
+        char *local_alloc_debug_buf;
+#endif
        /* Next two fields are for local node slot recovery during
         * mount. */
        int dirty;
@@ -340,6 +369,13 @@ static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb)
        return 0;
 }
+static inline int ocfs2_supports_xattr(struct ocfs2_super *osb)
+{
+        if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR)
+                return 1;
+        return 0;
+}
 /* set / clear functions because cluster events can make these happen
 * in parallel so we want the transitions to be atomic. this also
 * means that any future flags osb_flags must be protected by spinlock
@@ -554,6 +590,14 @@ static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb)
        return pages_per_cluster;
 }
+static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb,
+                                                       unsigned int megs)
+{
+        BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576);
+        return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits);
+}
 static inline void ocfs2_init_inode_steal_slot(struct ocfs2_super *osb)
 {
        spin_lock(&osb->osb_lock);
diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h
index 4f619850ccf7..f24ce3d3f956 100644
--- a/fs/ocfs2/ocfs2_fs.h
+++ b/fs/ocfs2/ocfs2_fs.h
@@ -64,6 +64,7 @@
 #define OCFS2_INODE_SIGNATURE           "INODE01"
 #define OCFS2_EXTENT_BLOCK_SIGNATURE    "EXBLK01"
 #define OCFS2_GROUP_DESC_SIGNATURE      "GROUP01"
+#define OCFS2_XATTR_BLOCK_SIGNATURE     "XATTR01"
 /* Compatibility flags */
 #define OCFS2_HAS_COMPAT_FEATURE(sb,mask)                       \
@@ -90,7 +91,8 @@
                                         | OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC \
                                         | OCFS2_FEATURE_INCOMPAT_INLINE_DATA \
                                         | OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP \
-                                         | OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK)
+                                         | OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK \
+                                         | OCFS2_FEATURE_INCOMPAT_XATTR)
 #define OCFS2_FEATURE_RO_COMPAT_SUPP    OCFS2_FEATURE_RO_COMPAT_UNWRITTEN
 /*
@@ -127,10 +129,6 @@
 /* Support for data packed into inode blocks */
 #define OCFS2_FEATURE_INCOMPAT_INLINE_DATA      0x0040
-/* Support for the extended slot map */
-#define OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP 0x100
 /*
 * Support for alternate, userspace cluster stacks.  If set, the superblock
 * field s_cluster_info contains a tag for the alternate stack in use as
@@ -142,6 +140,12 @@
 */
 #define OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK  0x0080
+/* Support for the extended slot map */
+#define OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP 0x100
+/* Support for extended attributes */
+#define OCFS2_FEATURE_INCOMPAT_XATTR            0x0200
 /*
 * backup superblock flag is used to indicate that this volume
 * has backup superblocks.
@@ -299,6 +303,12 @@ struct ocfs2_new_group_input {
 */
 #define OCFS2_DEFAULT_LOCAL_ALLOC_SIZE  8
+/*
+ * Inline extended attribute size (in bytes)
+ * The value chosen should be aligned to 16 byte boundaries.
+ */
+#define OCFS2_MIN_XATTR_INLINE_SIZE     256
 struct ocfs2_system_inode_info {
        char    *si_name;
        int     si_iflags;
@@ -563,7 +573,7 @@ struct ocfs2_super_block {
 /*40*/  __le16 s_max_slots;             /* Max number of simultaneous mounts
                                           before tunefs required */
        __le16 s_tunefs_flag;
-        __le32 s_reserved1;
+        __le32 s_uuid_hash;             /* hash value of uuid */
        __le64 s_first_cluster_group;   /* Block offset of 1st cluster
                                         * group header */
 /*50*/  __u8  s_label[OCFS2_MAX_VOL_LABEL_LEN]; /* Label for mounting, etc. */
@@ -571,7 +581,11 @@ struct ocfs2_super_block {
 /*A0*/  struct ocfs2_cluster_info s_cluster_info; /* Selected userspace
                                                     stack.  Only valid
                                                     with INCOMPAT flag. */
-/*B8*/  __le64 s_reserved2[17];         /* Fill out superblock */
+/*B8*/  __le16 s_xattr_inline_size;     /* extended attribute inline size
+                                           for this fs*/
+        __le16 s_reserved0;
+        __le32 s_reserved1;
+/*C0*/  __le64 s_reserved2[16];         /* Fill out superblock */
 /*140*/
        /*
@@ -621,7 +635,8 @@ struct ocfs2_dinode {
                                           belongs to */
        __le16 i_suballoc_bit;          /* Bit offset in suballocator
                                           block group */
-/*10*/  __le32 i_reserved0;
+/*10*/  __le16 i_reserved0;
+        __le16 i_xattr_inline_size;
        __le32 i_clusters;              /* Cluster count */
        __le32 i_uid;                   /* Owner UID */
        __le32 i_gid;                   /* Owning GID */
@@ -640,11 +655,12 @@ struct ocfs2_dinode {
        __le32 i_atime_nsec;
        __le32 i_ctime_nsec;
        __le32 i_mtime_nsec;
-        __le32 i_attr;
+/*70*/  __le32 i_attr;
        __le16 i_orphaned_slot;         /* Only valid when OCFS2_ORPHANED_FL
                                           was set in i_flags */
        __le16 i_dyn_features;
-/*70*/  __le64 i_reserved2[8];
+        __le64 i_xattr_loc;
+/*80*/  __le64 i_reserved2[7];
 /*B8*/  union {
                __le64 i_pad1;          /* Generic way to refer to this
                                           64bit union */
@@ -715,6 +731,136 @@ struct ocfs2_group_desc
 /*40*/  __u8    bg_bitmap[0];
 };
+/*
+ * On disk extended attribute structure for OCFS2.
+ */
+/*
+ * ocfs2_xattr_entry indicates one extend attribute.
+ *
+ * Note that it can be stored in inode, one block or one xattr bucket.
+ */
+struct ocfs2_xattr_entry {
+        __le32  xe_name_hash;    /* hash value of xattr prefix+suffix. */
+        __le16  xe_name_offset;  /* byte offset from the 1st etnry in the local
+                                    local xattr storage(inode, xattr block or
+                                    xattr bucket). */
+        __u8    xe_name_len;     /* xattr name len, does't include prefix. */
+        __u8    xe_type;         /* the low 7 bits indicates the name prefix's
+                                  * type and the highest 1 bits indicate whether
+                                  * the EA is stored in the local storage. */
+        __le64  xe_value_size;   /* real xattr value length. */
+};
+/*
+ * On disk structure for xattr header.
+ *
+ * One ocfs2_xattr_header describes how many ocfs2_xattr_entry records in
+ * the local xattr storage.
+ */
+struct ocfs2_xattr_header {
+        __le16  xh_count;                       /* contains the count of how
+                                                   many records are in the
+                                                   local xattr storage. */
+        __le16  xh_free_start;                  /* current offset for storing
+                                                   xattr. */
+        __le16  xh_name_value_len;              /* total length of name/value
+                                                   length in this bucket. */
+        __le16  xh_num_buckets;                 /* bucket nums in one extent
+                                                   record, only valid in the
+                                                   first bucket. */
+        __le64  xh_csum;
+        struct ocfs2_xattr_entry xh_entries[0]; /* xattr entry list. */
+};
+/*
+ * On disk structure for xattr value root.
+ *
+ * It is used when one extended attribute's size is larger, and we will save it
+ * in an outside cluster. It will stored in a b-tree like file content.
+ */
+struct ocfs2_xattr_value_root {
+/*00*/  __le32  xr_clusters;              /* clusters covered by xattr value. */
+        __le32  xr_reserved0;
+        __le64  xr_last_eb_blk;           /* Pointer to last extent block */
+/*10*/  struct ocfs2_extent_list xr_list; /* Extent record list */
+};
+/*
+ * On disk structure for xattr tree root.
+ *
+ * It is used when there are too many extended attributes for one file. These
+ * attributes will be organized and stored in an indexed-btree.
+ */
+struct ocfs2_xattr_tree_root {
+/*00*/  __le32  xt_clusters;              /* clusters covered by xattr. */
+        __le32  xt_reserved0;
+        __le64  xt_last_eb_blk;           /* Pointer to last extent block */
+/*10*/  struct ocfs2_extent_list xt_list; /* Extent record list */
+};
+#define OCFS2_XATTR_INDEXED     0x1
+#define OCFS2_HASH_SHIFT        5
+#define OCFS2_XATTR_ROUND       3
+#define OCFS2_XATTR_SIZE(size)  (((size) + OCFS2_XATTR_ROUND) & \
+                                ~(OCFS2_XATTR_ROUND))
+#define OCFS2_XATTR_BUCKET_SIZE                 4096
+#define OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET       (OCFS2_XATTR_BUCKET_SIZE \
+                                                 / OCFS2_MIN_BLOCKSIZE)
+/*
+ * On disk structure for xattr block.
+ */
+struct ocfs2_xattr_block {
+/*00*/  __u8    xb_signature[8];     /* Signature for verification */
+        __le16  xb_suballoc_slot;    /* Slot suballocator this
+                                        block belongs to. */
+        __le16  xb_suballoc_bit;     /* Bit offset in suballocator
+                                        block group */
+        __le32  xb_fs_generation;    /* Must match super block */
+/*10*/  __le64  xb_blkno;            /* Offset on disk, in blocks */
+        __le64  xb_csum;
+/*20*/  __le16  xb_flags;            /* Indicates whether this block contains
+                                        real xattr or a xattr tree. */
+        __le16  xb_reserved0;
+        __le32  xb_reserved1;
+        __le64  xb_reserved2;
+/*30*/  union {
+                struct ocfs2_xattr_header xb_header; /* xattr header if this
+                                                        block contains xattr */
+                struct ocfs2_xattr_tree_root xb_root;/* xattr tree root if this
+                                                        block cotains xattr
+                                                        tree. */
+        } xb_attrs;
+};
+#define OCFS2_XATTR_ENTRY_LOCAL         0x80
+#define OCFS2_XATTR_TYPE_MASK           0x7F
+static inline void ocfs2_xattr_set_local(struct ocfs2_xattr_entry *xe,
+                                         int local)
+{
+        if (local)
+                xe->xe_type |= OCFS2_XATTR_ENTRY_LOCAL;
+        else
+                xe->xe_type &= ~OCFS2_XATTR_ENTRY_LOCAL;
+}
+static inline int ocfs2_xattr_is_local(struct ocfs2_xattr_entry *xe)
+{
+        return xe->xe_type & OCFS2_XATTR_ENTRY_LOCAL;
+}
+static inline void ocfs2_xattr_set_type(struct ocfs2_xattr_entry *xe, int type)
+{
+        xe->xe_type |= type & OCFS2_XATTR_TYPE_MASK;
+}
+static inline int ocfs2_xattr_get_type(struct ocfs2_xattr_entry *xe)
+{
+        return xe->xe_type & OCFS2_XATTR_TYPE_MASK;
+}
 #ifdef __KERNEL__
 static inline int ocfs2_fast_symlink_chars(struct super_block *sb)
 {
@@ -728,6 +874,20 @@ static inline int ocfs2_max_inline_data(struct super_block *sb)
                offsetof(struct ocfs2_dinode, id2.i_data.id_data);
 }
+static inline int ocfs2_max_inline_data_with_xattr(struct super_block *sb,
+                                                   struct ocfs2_dinode *di)
+{
+        unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
+        if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
+                return sb->s_blocksize -
+                        offsetof(struct ocfs2_dinode, id2.i_data.id_data) -
+                        xattrsize;
+        else
+                return sb->s_blocksize -
+                        offsetof(struct ocfs2_dinode, id2.i_data.id_data);
+}
 static inline int ocfs2_extent_recs_per_inode(struct super_block *sb)
 {
        int size;
@@ -738,6 +898,24 @@ static inline int ocfs2_extent_recs_per_inode(struct super_block *sb)
        return size / sizeof(struct ocfs2_extent_rec);
 }
+static inline int ocfs2_extent_recs_per_inode_with_xattr(
+                                                struct super_block *sb,
+                                                struct ocfs2_dinode *di)
+{
+        int size;
+        unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
+        if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
+                size = sb->s_blocksize -
+                        offsetof(struct ocfs2_dinode, id2.i_list.l_recs) -
+                        xattrsize;
+        else
+                size = sb->s_blocksize -
+                        offsetof(struct ocfs2_dinode, id2.i_list.l_recs);
+        return size / sizeof(struct ocfs2_extent_rec);
+}
 static inline int ocfs2_chain_recs_per_inode(struct super_block *sb)
 {
        int size;
@@ -801,6 +979,17 @@ static inline u64 ocfs2_backup_super_blkno(struct super_block *sb, int index)
        return 0;
 }
+static inline u16 ocfs2_xattr_recs_per_xb(struct super_block *sb)
+{
+        int size;
+        size = sb->s_blocksize -
+                offsetof(struct ocfs2_xattr_block,
+                         xb_attrs.xb_root.xt_list.l_recs);
+        return size / sizeof(struct ocfs2_extent_rec);
+}
 #else
 static inline int ocfs2_fast_symlink_chars(int blocksize)
 {
@@ -884,6 +1073,17 @@ static inline uint64_t ocfs2_backup_super_blkno(int blocksize, int index)
        return 0;
 }
+static inline int ocfs2_xattr_recs_per_xb(int blocksize)
+{
+        int size;
+        size = blocksize -
+                offsetof(struct ocfs2_xattr_block,
+                         xb_attrs.xb_root.xt_list.l_recs);
+        return size / sizeof(struct ocfs2_extent_rec);
+}
 #endif  /* __KERNEL__ */
diff --git a/fs/ocfs2/ocfs2_jbd_compat.h b/fs/ocfs2/ocfs2_jbd_compat.h
new file mode 100644
index 000000000000..b91c78f8f558
--- /dev/null
+++ b/fs/ocfs2/ocfs2_jbd_compat.h
@@ -0,0 +1,82 @@
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * ocfs2_jbd_compat.h
+ *
+ * Compatibility defines for JBD.
+ *
+ * Copyright (C) 2008 Oracle.  All rights reserved.
+ *
+ * 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.
+ *
+ * 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.
+ */
+#ifndef OCFS2_JBD_COMPAT_H
+#define OCFS2_JBD_COMPAT_H
+#ifndef CONFIG_OCFS2_COMPAT_JBD
+# error Should not have been included
+#endif
+struct jbd2_inode {
+        unsigned int dummy;
+};
+#define JBD2_BARRIER                    JFS_BARRIER
+#define JBD2_DEFAULT_MAX_COMMIT_AGE     JBD_DEFAULT_MAX_COMMIT_AGE
+#define jbd2_journal_ack_err                    journal_ack_err
+#define jbd2_journal_clear_err                  journal_clear_err
+#define jbd2_journal_destroy                    journal_destroy
+#define jbd2_journal_dirty_metadata             journal_dirty_metadata
+#define jbd2_journal_errno                      journal_errno
+#define jbd2_journal_extend                     journal_extend
+#define jbd2_journal_flush                      journal_flush
+#define jbd2_journal_force_commit               journal_force_commit
+#define jbd2_journal_get_write_access           journal_get_write_access
+#define jbd2_journal_get_undo_access            journal_get_undo_access
+#define jbd2_journal_init_inode                 journal_init_inode
+#define jbd2_journal_invalidatepage             journal_invalidatepage
+#define jbd2_journal_load                       journal_load
+#define jbd2_journal_lock_updates               journal_lock_updates
+#define jbd2_journal_restart                    journal_restart
+#define jbd2_journal_start                      journal_start
+#define jbd2_journal_start_commit               journal_start_commit
+#define jbd2_journal_stop                       journal_stop
+#define jbd2_journal_try_to_free_buffers        journal_try_to_free_buffers
+#define jbd2_journal_unlock_updates             journal_unlock_updates
+#define jbd2_journal_wipe                       journal_wipe
+#define jbd2_log_wait_commit                    log_wait_commit
+static inline int jbd2_journal_file_inode(handle_t *handle,
+                                          struct jbd2_inode *inode)
+{
+        return 0;
+}
+static inline int jbd2_journal_begin_ordered_truncate(struct jbd2_inode *inode,
+                                                      loff_t new_size)
+{
+        return 0;
+}
+static inline void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode,
+                                               struct inode *inode)
+{
+        return;
+}
+static inline void jbd2_journal_release_jbd_inode(journal_t *journal,
+                                                  struct jbd2_inode *jinode)
+{
+        return;
+}
+#endif  /* OCFS2_JBD_COMPAT_H */
diff --git a/fs/ocfs2/resize.c b/fs/ocfs2/resize.c
index 8166968e9015..ffd48db229a7 100644
--- a/fs/ocfs2/resize.c
+++ b/fs/ocfs2/resize.c
@@ -200,7 +200,7 @@ static int update_backups(struct inode * inode, u32 clusters, char *data)
                if (cluster > clusters)
                        break;
-                ret = ocfs2_read_block(osb, blkno, &backup, 0, NULL);
+                ret = ocfs2_read_blocks_sync(osb, blkno, 1, &backup);
                if (ret < 0) {
                        mlog_errno(ret);
                        break;
@@ -236,8 +236,8 @@ static void ocfs2_update_super_and_backups(struct inode *inode,
         * update the superblock last.
         * It doesn't matter if the write failed.
         */
-        ret = ocfs2_read_block(osb, OCFS2_SUPER_BLOCK_BLKNO,
+        ret = ocfs2_read_blocks_sync(osb, OCFS2_SUPER_BLOCK_BLKNO, 1,
-                               &super_bh, 0, NULL);
+                                     &super_bh);
        if (ret < 0) {
                mlog_errno(ret);
                goto out;
@@ -332,8 +332,7 @@ int ocfs2_group_extend(struct inode * inode, int new_clusters)
        lgd_blkno = ocfs2_which_cluster_group(main_bm_inode,
                                              first_new_cluster - 1);
-        ret = ocfs2_read_block(osb, lgd_blkno, &group_bh, OCFS2_BH_CACHED,
+        ret = ocfs2_read_block(main_bm_inode, lgd_blkno, &group_bh);
-                               main_bm_inode);
        if (ret < 0) {
                mlog_errno(ret);
                goto out_unlock;
@@ -540,7 +539,7 @@ int ocfs2_group_add(struct inode *inode, struct ocfs2_new_group_input *input)
                goto out_unlock;
        }
-        ret = ocfs2_read_block(osb, input->group, &group_bh, 0, NULL);
+        ret = ocfs2_read_blocks_sync(osb, input->group, 1, &group_bh);
        if (ret < 0) {
                mlog(ML_ERROR, "Can't read the group descriptor # %llu "
                     "from the device.", (unsigned long long)input->group);
diff --git a/fs/ocfs2/slot_map.c b/fs/ocfs2/slot_map.c
index bb5ff8939bf1..bdda2d8f8508 100644
--- a/fs/ocfs2/slot_map.c
+++ b/fs/ocfs2/slot_map.c
@@ -150,8 +150,8 @@ int ocfs2_refresh_slot_info(struct ocfs2_super *osb)
         * be !NULL.  Thus, ocfs2_read_blocks() will ignore blocknr.  If
         * this is not true, the read of -1 (UINT64_MAX) will fail.
         */
-        ret = ocfs2_read_blocks(osb, -1, si->si_blocks, si->si_bh, 0,
+        ret = ocfs2_read_blocks(si->si_inode, -1, si->si_blocks, si->si_bh,
-                                si->si_inode);
+                                OCFS2_BH_IGNORE_CACHE);
        if (ret == 0) {
                spin_lock(&osb->osb_lock);
                ocfs2_update_slot_info(si);
@@ -404,7 +404,8 @@ static int ocfs2_map_slot_buffers(struct ocfs2_super *osb,
                     (unsigned long long)blkno);
                bh = NULL;  /* Acquire a fresh bh */
-                status = ocfs2_read_block(osb, blkno, &bh, 0, si->si_inode);
+                status = ocfs2_read_blocks(si->si_inode, blkno, 1, &bh,
+                                           OCFS2_BH_IGNORE_CACHE);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c
index 353fc35c6748..faec2d879357 100644
--- a/fs/ocfs2/stack_user.c
+++ b/fs/ocfs2/stack_user.c
@@ -28,6 +28,7 @@
 #include "ocfs2.h"  /* For struct ocfs2_lock_res */
 #include "stackglue.h"
+#include <linux/dlm_plock.h>
 /*
 * The control protocol starts with a handshake.  Until the handshake
@@ -746,6 +747,37 @@ static void user_dlm_dump_lksb(union ocfs2_dlm_lksb *lksb)
 {
 }
+static int user_plock(struct ocfs2_cluster_connection *conn,
+                      u64 ino,
+                      struct file *file,
+                      int cmd,
+                      struct file_lock *fl)
+{
+        /*
+         * This more or less just demuxes the plock request into any
+         * one of three dlm calls.
+         *
+         * Internally, fs/dlm will pass these to a misc device, which
+         * a userspace daemon will read and write to.
+         *
+         * For now, cancel requests (which happen internally only),
+         * are turned into unlocks. Most of this function taken from
+         * gfs2_lock.
+         */
+        if (cmd == F_CANCELLK) {
+                cmd = F_SETLK;
+                fl->fl_type = F_UNLCK;
+        }
+        if (IS_GETLK(cmd))
+                return dlm_posix_get(conn->cc_lockspace, ino, file, fl);
+        else if (fl->fl_type == F_UNLCK)
+                return dlm_posix_unlock(conn->cc_lockspace, ino, file, fl);
+        else
+                return dlm_posix_lock(conn->cc_lockspace, ino, file, cmd, fl);
+}
 /*
 * Compare a requested locking protocol version against the current one.
 *
@@ -839,6 +871,7 @@ static struct ocfs2_stack_operations ocfs2_user_plugin_ops = {
        .dlm_unlock     = user_dlm_unlock,
        .lock_status    = user_dlm_lock_status,
        .lock_lvb       = user_dlm_lvb,
+        .plock          = user_plock,
        .dump_lksb      = user_dlm_dump_lksb,
 };
diff --git a/fs/ocfs2/stackglue.c b/fs/ocfs2/stackglue.c
index 07f348b8d721..68b668b0e60a 100644
--- a/fs/ocfs2/stackglue.c
+++ b/fs/ocfs2/stackglue.c
@@ -288,6 +288,26 @@ void ocfs2_dlm_dump_lksb(union ocfs2_dlm_lksb *lksb)
 }
 EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb);
+int ocfs2_stack_supports_plocks(void)
+{
+        return active_stack && active_stack->sp_ops->plock;
+}
+EXPORT_SYMBOL_GPL(ocfs2_stack_supports_plocks);
+/*
+ * ocfs2_plock() can only be safely called if
+ * ocfs2_stack_supports_plocks() returned true
+ */
+int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino,
+                struct file *file, int cmd, struct file_lock *fl)
+{
+        WARN_ON_ONCE(active_stack->sp_ops->plock == NULL);
+        if (active_stack->sp_ops->plock)
+                return active_stack->sp_ops->plock(conn, ino, file, cmd, fl);
+        return -EOPNOTSUPP;
+}
+EXPORT_SYMBOL_GPL(ocfs2_plock);
 int ocfs2_cluster_connect(const char *stack_name,
                          const char *group,
                          int grouplen,
diff --git a/fs/ocfs2/stackglue.h b/fs/ocfs2/stackglue.h
index db56281dd1be..c571af375ef8 100644
--- a/fs/ocfs2/stackglue.h
+++ b/fs/ocfs2/stackglue.h
@@ -28,6 +28,10 @@
 #include "dlm/dlmapi.h"
 #include <linux/dlm.h>
+/* Needed for plock-related prototypes */
+struct file;
+struct file_lock;
 /*
 * dlmconstants.h does not have a LOCAL flag.  We hope to remove it
 * some day, but right now we need it.  Let's fake it.  This value is larger
@@ -187,6 +191,17 @@ struct ocfs2_stack_operations {
        void *(*lock_lvb)(union ocfs2_dlm_lksb *lksb);
        /*
+         * Cluster-aware posix locks
+         *
+         * This is NULL for stacks which do not support posix locks.
+         */
+        int (*plock)(struct ocfs2_cluster_connection *conn,
+                     u64 ino,
+                     struct file *file,
+                     int cmd,
+                     struct file_lock *fl);
+        /*
         * This is an optoinal debugging hook.  If provided, the
         * stack can dump debugging information about this lock.
         */
@@ -240,6 +255,10 @@ int ocfs2_dlm_lock_status(union ocfs2_dlm_lksb *lksb);
 void *ocfs2_dlm_lvb(union ocfs2_dlm_lksb *lksb);
 void ocfs2_dlm_dump_lksb(union ocfs2_dlm_lksb *lksb);
+int ocfs2_stack_supports_plocks(void);
+int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino,
+                struct file *file, int cmd, struct file_lock *fl);
 void ocfs2_stack_glue_set_locking_protocol(struct ocfs2_locking_protocol *proto);
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index d2d278fb9819..c5ff18b46b57 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -62,15 +62,18 @@ static int ocfs2_block_group_fill(handle_t *handle,
                                  struct ocfs2_chain_list *cl);
 static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
                                   struct inode *alloc_inode,
-                                   struct buffer_head *bh);
+                                   struct buffer_head *bh,
+                                   u64 max_block);
 static int ocfs2_cluster_group_search(struct inode *inode,
                                      struct buffer_head *group_bh,
                                      u32 bits_wanted, u32 min_bits,
+                                      u64 max_block,
                                      u16 *bit_off, u16 *bits_found);
 static int ocfs2_block_group_search(struct inode *inode,
                                    struct buffer_head *group_bh,
                                    u32 bits_wanted, u32 min_bits,
+                                    u64 max_block,
                                    u16 *bit_off, u16 *bits_found);
 static int ocfs2_claim_suballoc_bits(struct ocfs2_super *osb,
                                     struct ocfs2_alloc_context *ac,
@@ -110,8 +113,11 @@ static inline void ocfs2_block_to_cluster_group(struct inode *inode,
                                                u64 data_blkno,
                                                u64 *bg_blkno,
                                                u16 *bg_bit_off);
+static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
+                                             u32 bits_wanted, u64 max_block,
+                                             struct ocfs2_alloc_context **ac);
-static void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
+void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
 {
        struct inode *inode = ac->ac_inode;
@@ -124,10 +130,8 @@ static void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
                iput(inode);
                ac->ac_inode = NULL;
        }
-        if (ac->ac_bh) {
+        brelse(ac->ac_bh);
-                brelse(ac->ac_bh);
+        ac->ac_bh = NULL;
-                ac->ac_bh = NULL;
-        }
 }
 void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
@@ -276,7 +280,8 @@ static inline u16 ocfs2_find_smallest_chain(struct ocfs2_chain_list *cl)
 */
 static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
                                   struct inode *alloc_inode,
-                                   struct buffer_head *bh)
+                                   struct buffer_head *bh,
+                                   u64 max_block)
 {
        int status, credits;
        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
@@ -294,9 +299,9 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
        mlog_entry_void();
        cl = &fe->id2.i_chain;
-        status = ocfs2_reserve_clusters(osb,
+        status = ocfs2_reserve_clusters_with_limit(osb,
-                                        le16_to_cpu(cl->cl_cpg),
+                                                   le16_to_cpu(cl->cl_cpg),
-                                        &ac);
+                                                   max_block, &ac);
        if (status < 0) {
                if (status != -ENOSPC)
                        mlog_errno(status);
@@ -394,8 +399,7 @@ bail:
        if (ac)
                ocfs2_free_alloc_context(ac);
-        if (bg_bh)
+        brelse(bg_bh);
-                brelse(bg_bh);
        mlog_exit(status);
        return status;
@@ -469,7 +473,8 @@ static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
                        goto bail;
                }
-                status = ocfs2_block_group_alloc(osb, alloc_inode, bh);
+                status = ocfs2_block_group_alloc(osb, alloc_inode, bh,
+                                                 ac->ac_max_block);
                if (status < 0) {
                        if (status != -ENOSPC)
                                mlog_errno(status);
@@ -486,16 +491,15 @@ static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
        get_bh(bh);
        ac->ac_bh = bh;
 bail:
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        mlog_exit(status);
        return status;
 }
-int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
+int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super *osb,
-                               struct ocfs2_dinode *fe,
+                                      int blocks,
-                               struct ocfs2_alloc_context **ac)
+                                      struct ocfs2_alloc_context **ac)
 {
        int status;
        u32 slot;
@@ -507,7 +511,7 @@ int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
                goto bail;
        }
-        (*ac)->ac_bits_wanted = ocfs2_extend_meta_needed(fe);
+        (*ac)->ac_bits_wanted = blocks;
        (*ac)->ac_which = OCFS2_AC_USE_META;
        slot = osb->slot_num;
        (*ac)->ac_group_search = ocfs2_block_group_search;
@@ -532,6 +536,15 @@ bail:
        return status;
 }
+int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
+                               struct ocfs2_extent_list *root_el,
+                               struct ocfs2_alloc_context **ac)
+{
+        return ocfs2_reserve_new_metadata_blocks(osb,
+                                        ocfs2_extend_meta_needed(root_el),
+                                        ac);
+}
 static int ocfs2_steal_inode_from_other_nodes(struct ocfs2_super *osb,
                                              struct ocfs2_alloc_context *ac)
 {
@@ -582,6 +595,14 @@ int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
        (*ac)->ac_group_search = ocfs2_block_group_search;
        /*
+         * stat(2) can't handle i_ino > 32bits, so we tell the
+         * lower levels not to allocate us a block group past that
+         * limit.  The 'inode64' mount option avoids this behavior.
+         */
+        if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64))
+                (*ac)->ac_max_block = (u32)~0U;
+        /*
         * slot is set when we successfully steal inode from other nodes.
         * It is reset in 3 places:
         * 1. when we flush the truncate log
@@ -661,9 +682,9 @@ bail:
 /* Callers don't need to care which bitmap (local alloc or main) to
 * use so we figure it out for them, but unfortunately this clutters
 * things a bit. */
-int ocfs2_reserve_clusters(struct ocfs2_super *osb,
+static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
-                           u32 bits_wanted,
+                                             u32 bits_wanted, u64 max_block,
-                           struct ocfs2_alloc_context **ac)
+                                             struct ocfs2_alloc_context **ac)
 {
        int status;
@@ -677,24 +698,20 @@ int ocfs2_reserve_clusters(struct ocfs2_super *osb,
        }
        (*ac)->ac_bits_wanted = bits_wanted;
+        (*ac)->ac_max_block = max_block;
        status = -ENOSPC;
        if (ocfs2_alloc_should_use_local(osb, bits_wanted)) {
                status = ocfs2_reserve_local_alloc_bits(osb,
                                                        bits_wanted,
                                                        *ac);
-                if ((status < 0) && (status != -ENOSPC)) {
+                if (status == -EFBIG) {
+                        /* The local alloc window is outside ac_max_block.
+                         * use the main bitmap. */
+                        status = -ENOSPC;
+                } else if ((status < 0) && (status != -ENOSPC)) {
                        mlog_errno(status);
                        goto bail;
-                } else if (status == -ENOSPC) {
-                        /* reserve_local_bits will return enospc with
-                         * the local alloc inode still locked, so we
-                         * can change this safely here. */
-                        mlog(0, "Disabling local alloc\n");
-                        /* We set to OCFS2_LA_DISABLED so that umount
-                         * can clean up what's left of the local
-                         * allocation */
-                        osb->local_alloc_state = OCFS2_LA_DISABLED;
                }
        }
@@ -718,6 +735,13 @@ bail:
        return status;
 }
+int ocfs2_reserve_clusters(struct ocfs2_super *osb,
+                           u32 bits_wanted,
+                           struct ocfs2_alloc_context **ac)
+{
+        return ocfs2_reserve_clusters_with_limit(osb, bits_wanted, 0, ac);
+}
 /*
 * More or less lifted from ext3. I'll leave their description below:
 *
@@ -1000,11 +1024,14 @@ static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg
 static int ocfs2_cluster_group_search(struct inode *inode,
                                      struct buffer_head *group_bh,
                                      u32 bits_wanted, u32 min_bits,
+                                      u64 max_block,
                                      u16 *bit_off, u16 *bits_found)
 {
        int search = -ENOSPC;
        int ret;
+        u64 blkoff;
        struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *) group_bh->b_data;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        u16 tmp_off, tmp_found;
        unsigned int max_bits, gd_cluster_off;
@@ -1037,6 +1064,17 @@ static int ocfs2_cluster_group_search(struct inode *inode,
                if (ret)
                        return ret;
+                if (max_block) {
+                        blkoff = ocfs2_clusters_to_blocks(inode->i_sb,
+                                                          gd_cluster_off +
+                                                          tmp_off + tmp_found);
+                        mlog(0, "Checking %llu against %llu\n",
+                             (unsigned long long)blkoff,
+                             (unsigned long long)max_block);
+                        if (blkoff > max_block)
+                                return -ENOSPC;
+                }
                /* ocfs2_block_group_find_clear_bits() might
                 * return success, but we still want to return
                 * -ENOSPC unless it found the minimum number
@@ -1045,6 +1083,12 @@ static int ocfs2_cluster_group_search(struct inode *inode,
                        *bit_off = tmp_off;
                        *bits_found = tmp_found;
                        search = 0; /* success */
+                } else if (tmp_found) {
+                        /*
+                         * Don't show bits which we'll be returning
+                         * for allocation to the local alloc bitmap.
+                         */
+                        ocfs2_local_alloc_seen_free_bits(osb, tmp_found);
                }
        }
@@ -1054,19 +1098,31 @@ static int ocfs2_cluster_group_search(struct inode *inode,
 static int ocfs2_block_group_search(struct inode *inode,
                                    struct buffer_head *group_bh,
                                    u32 bits_wanted, u32 min_bits,
+                                    u64 max_block,
                                    u16 *bit_off, u16 *bits_found)
 {
        int ret = -ENOSPC;
+        u64 blkoff;
        struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) group_bh->b_data;
        BUG_ON(min_bits != 1);
        BUG_ON(ocfs2_is_cluster_bitmap(inode));
-        if (bg->bg_free_bits_count)
+        if (bg->bg_free_bits_count) {
                ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb),
                                                        group_bh, bits_wanted,
                                                        le16_to_cpu(bg->bg_bits),
                                                        bit_off, bits_found);
+                if (!ret && max_block) {
+                        blkoff = le64_to_cpu(bg->bg_blkno) + *bit_off +
+                                *bits_found;
+                        mlog(0, "Checking %llu against %llu\n",
+                             (unsigned long long)blkoff,
+                             (unsigned long long)max_block);
+                        if (blkoff > max_block)
+                                ret = -ENOSPC;
+                }
+        }
        return ret;
 }
@@ -1116,8 +1172,7 @@ static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
        struct ocfs2_group_desc *gd;
        struct inode *alloc_inode = ac->ac_inode;
-        ret = ocfs2_read_block(OCFS2_SB(alloc_inode->i_sb), gd_blkno,
+        ret = ocfs2_read_block(alloc_inode, gd_blkno, &group_bh);
-                               &group_bh, OCFS2_BH_CACHED, alloc_inode);
        if (ret < 0) {
                mlog_errno(ret);
                return ret;
@@ -1131,7 +1186,7 @@ static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
        }
        ret = ac->ac_group_search(alloc_inode, group_bh, bits_wanted, min_bits,
-                                  bit_off, &found);
+                                  ac->ac_max_block, bit_off, &found);
        if (ret < 0) {
                if (ret != -ENOSPC)
                        mlog_errno(ret);
@@ -1186,9 +1241,9 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
             bits_wanted, chain,
             (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno);
-        status = ocfs2_read_block(OCFS2_SB(alloc_inode->i_sb),
+        status = ocfs2_read_block(alloc_inode,
                                  le64_to_cpu(cl->cl_recs[chain].c_blkno),
-                                  &group_bh, OCFS2_BH_CACHED, alloc_inode);
+                                  &group_bh);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -1204,21 +1259,20 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
        /* for now, the chain search is a bit simplistic. We just use
         * the 1st group with any empty bits. */
        while ((status = ac->ac_group_search(alloc_inode, group_bh,
-                                             bits_wanted, min_bits, bit_off,
+                                             bits_wanted, min_bits,
+                                             ac->ac_max_block, bit_off,
                                             &tmp_bits)) == -ENOSPC) {
                if (!bg->bg_next_group)
                        break;
-                if (prev_group_bh) {
+                brelse(prev_group_bh);
-                        brelse(prev_group_bh);
+                prev_group_bh = NULL;
-                        prev_group_bh = NULL;
-                }
                next_group = le64_to_cpu(bg->bg_next_group);
                prev_group_bh = group_bh;
                group_bh = NULL;
-                status = ocfs2_read_block(OCFS2_SB(alloc_inode->i_sb),
+                status = ocfs2_read_block(alloc_inode,
-                                          next_group, &group_bh,
+                                          next_group, &group_bh);
-                                          OCFS2_BH_CACHED, alloc_inode);
                if (status < 0) {
                        mlog_errno(status);
                        goto bail;
@@ -1307,10 +1361,8 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
        *bg_blkno = le64_to_cpu(bg->bg_blkno);
        *bits_left = le16_to_cpu(bg->bg_free_bits_count);
 bail:
-        if (group_bh)
+        brelse(group_bh);
-                brelse(group_bh);
+        brelse(prev_group_bh);
-        if (prev_group_bh)
-                brelse(prev_group_bh);
        mlog_exit(status);
        return status;
@@ -1723,7 +1775,6 @@ int ocfs2_free_suballoc_bits(handle_t *handle,
 {
        int status = 0;
        u32 tmp_used;
-        struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
        struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data;
        struct ocfs2_chain_list *cl = &fe->id2.i_chain;
        struct buffer_head *group_bh = NULL;
@@ -1742,8 +1793,7 @@ int ocfs2_free_suballoc_bits(handle_t *handle,
             (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno, count,
             (unsigned long long)bg_blkno, start_bit);
-        status = ocfs2_read_block(osb, bg_blkno, &group_bh, OCFS2_BH_CACHED,
+        status = ocfs2_read_block(alloc_inode, bg_blkno, &group_bh);
-                                  alloc_inode);
        if (status < 0) {
                mlog_errno(status);
                goto bail;
@@ -1784,8 +1834,7 @@ int ocfs2_free_suballoc_bits(handle_t *handle,
        }
 bail:
-        if (group_bh)
+        brelse(group_bh);
-                brelse(group_bh);
        mlog_exit(status);
        return status;
@@ -1838,9 +1887,15 @@ int ocfs2_free_clusters(handle_t *handle,
        status = ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh,
                                          bg_start_bit, bg_blkno,
                                          num_clusters);
-        if (status < 0)
+        if (status < 0) {
                mlog_errno(status);
+                goto out;
+        }
+        ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb),
+                                         num_clusters);
+out:
        mlog_exit(status);
        return status;
 }
@@ -1891,3 +1946,84 @@ static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe)
                       (unsigned long long)fe->id2.i_chain.cl_recs[i].c_blkno);
        }
 }
+/*
+ * For a given allocation, determine which allocators will need to be
+ * accessed, and lock them, reserving the appropriate number of bits.
+ *
+ * Sparse file systems call this from ocfs2_write_begin_nolock()
+ * and ocfs2_allocate_unwritten_extents().
+ *
+ * File systems which don't support holes call this from
+ * ocfs2_extend_allocation().
+ */
+int ocfs2_lock_allocators(struct inode *inode,
+                          struct ocfs2_extent_tree *et,
+                          u32 clusters_to_add, u32 extents_to_split,
+                          struct ocfs2_alloc_context **data_ac,
+                          struct ocfs2_alloc_context **meta_ac)
+{
+        int ret = 0, num_free_extents;
+        unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        *meta_ac = NULL;
+        if (data_ac)
+                *data_ac = NULL;
+        BUG_ON(clusters_to_add != 0 && data_ac == NULL);
+        num_free_extents = ocfs2_num_free_extents(osb, inode, et);
+        if (num_free_extents < 0) {
+                ret = num_free_extents;
+                mlog_errno(ret);
+                goto out;
+        }
+        /*
+         * Sparse allocation file systems need to be more conservative
+         * with reserving room for expansion - the actual allocation
+         * happens while we've got a journal handle open so re-taking
+         * a cluster lock (because we ran out of room for another
+         * extent) will violate ordering rules.
+         *
+         * Most of the time we'll only be seeing this 1 cluster at a time
+         * anyway.
+         *
+         * Always lock for any unwritten extents - we might want to
+         * add blocks during a split.
+         */
+        if (!num_free_extents ||
+            (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) {
+                ret = ocfs2_reserve_new_metadata(osb, et->et_root_el, meta_ac);
+                if (ret < 0) {
+                        if (ret != -ENOSPC)
+                                mlog_errno(ret);
+                        goto out;
+                }
+        }
+        if (clusters_to_add == 0)
+                goto out;
+        ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac);
+        if (ret < 0) {
+                if (ret != -ENOSPC)
+                        mlog_errno(ret);
+                goto out;
+        }
+out:
+        if (ret) {
+                if (*meta_ac) {
+                        ocfs2_free_alloc_context(*meta_ac);
+                        *meta_ac = NULL;
+                }
+                /*
+                 * We cannot have an error and a non null *data_ac.
+                 */
+        }
+        return ret;
+}
diff --git a/fs/ocfs2/suballoc.h b/fs/ocfs2/suballoc.h
index 544c600662bd..4df159d8f450 100644
--- a/fs/ocfs2/suballoc.h
+++ b/fs/ocfs2/suballoc.h
@@ -28,10 +28,11 @@
 typedef int (group_search_t)(struct inode *,
                             struct buffer_head *,
-                             u32,
+                             u32,                       /* bits_wanted */
-                             u32,
+                             u32,                       /* min_bits */
-                             u16 *,
+                             u64,                       /* max_block */
-                             u16 *);
+                             u16 *,                     /* *bit_off */
+                             u16 *);                    /* *bits_found */
 struct ocfs2_alloc_context {
        struct inode *ac_inode;    /* which bitmap are we allocating from? */
@@ -51,6 +52,8 @@ struct ocfs2_alloc_context {
        group_search_t *ac_group_search;
        u64    ac_last_group;
+        u64    ac_max_block;  /* Highest block number to allocate. 0 is
+                                 is the same as ~0 - unlimited */
 };
 void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac);
@@ -59,9 +62,17 @@ static inline int ocfs2_alloc_context_bits_left(struct ocfs2_alloc_context *ac)
        return ac->ac_bits_wanted - ac->ac_bits_given;
 }
+/*
+ * Please note that the caller must make sure that root_el is the root
+ * of extent tree. So for an inode, it should be &fe->id2.i_list. Otherwise
+ * the result may be wrong.
+ */
 int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
-                               struct ocfs2_dinode *fe,
+                               struct ocfs2_extent_list *root_el,
                               struct ocfs2_alloc_context **ac);
+int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super *osb,
+                                      int blocks,
+                                      struct ocfs2_alloc_context **ac);
 int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
                            struct ocfs2_alloc_context **ac);
 int ocfs2_reserve_clusters(struct ocfs2_super *osb,
@@ -147,6 +158,7 @@ static inline int ocfs2_is_cluster_bitmap(struct inode *inode)
 * apis above. */
 int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
                                      struct ocfs2_alloc_context *ac);
+void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac);
 /* given a cluster offset, calculate which block group it belongs to
 * and return that block offset. */
@@ -156,4 +168,8 @@ u64 ocfs2_which_cluster_group(struct inode *inode, u32 cluster);
 int ocfs2_check_group_descriptor(struct super_block *sb,
                                 struct ocfs2_dinode *di,
                                 struct ocfs2_group_desc *gd);
+int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_extent_tree *et,
+                          u32 clusters_to_add, u32 extents_to_split,
+                          struct ocfs2_alloc_context **data_ac,
+                          struct ocfs2_alloc_context **meta_ac);
 #endif /* _CHAINALLOC_H_ */
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 70334d85aff1..304b63ac78cf 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -64,6 +64,7 @@
 #include "sysfile.h"
 #include "uptodate.h"
 #include "ver.h"
+#include "xattr.h"
 #include "buffer_head_io.h"
@@ -154,6 +155,9 @@ enum {
        Opt_localalloc,
        Opt_localflocks,
        Opt_stack,
+        Opt_user_xattr,
+        Opt_nouser_xattr,
+        Opt_inode64,
        Opt_err,
 };
@@ -173,6 +177,9 @@ static const match_table_t tokens = {
        {Opt_localalloc, "localalloc=%d"},
        {Opt_localflocks, "localflocks"},
        {Opt_stack, "cluster_stack=%s"},
+        {Opt_user_xattr, "user_xattr"},
+        {Opt_nouser_xattr, "nouser_xattr"},
+        {Opt_inode64, "inode64"},
        {Opt_err, NULL}
 };
@@ -205,10 +212,11 @@ static int ocfs2_sync_fs(struct super_block *sb, int wait)
                ocfs2_schedule_truncate_log_flush(osb, 0);
        }
-        if (journal_start_commit(OCFS2_SB(sb)->journal->j_journal, &target)) {
+        if (jbd2_journal_start_commit(OCFS2_SB(sb)->journal->j_journal,
+                                      &target)) {
                if (wait)
-                        log_wait_commit(OCFS2_SB(sb)->journal->j_journal,
+                        jbd2_log_wait_commit(OCFS2_SB(sb)->journal->j_journal,
-                                        target);
+                                             target);
        }
        return 0;
 }
@@ -325,6 +333,7 @@ static struct inode *ocfs2_alloc_inode(struct super_block *sb)
        if (!oi)
                return NULL;
+        jbd2_journal_init_jbd_inode(&oi->ip_jinode, &oi->vfs_inode);
        return &oi->vfs_inode;
 }
@@ -406,6 +415,15 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
                goto out;
        }
+        /* Probably don't want this on remount; it might
+         * mess with other nodes */
+        if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64) &&
+            (parsed_options.mount_opt & OCFS2_MOUNT_INODE64)) {
+                ret = -EINVAL;
+                mlog(ML_ERROR, "Cannot enable inode64 on remount\n");
+                goto out;
+        }
        /* We're going to/from readonly mode. */
        if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
                /* Lock here so the check of HARD_RO and the potential
@@ -637,7 +655,8 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
        osb->s_atime_quantum = parsed_options.atime_quantum;
        osb->preferred_slot = parsed_options.slot;
        osb->osb_commit_interval = parsed_options.commit_interval;
-        osb->local_alloc_size = parsed_options.localalloc_opt;
+        osb->local_alloc_default_bits = ocfs2_megabytes_to_clusters(sb, parsed_options.localalloc_opt);
+        osb->local_alloc_bits = osb->local_alloc_default_bits;
        status = ocfs2_verify_userspace_stack(osb, &parsed_options);
        if (status)
@@ -743,8 +762,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
        return status;
 read_super_error:
-        if (bh != NULL)
+        brelse(bh);
-                brelse(bh);
        if (inode)
                iput(inode);
@@ -847,6 +865,12 @@ static int ocfs2_parse_options(struct super_block *sb,
                case Opt_data_writeback:
                        mopt->mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK;
                        break;
+                case Opt_user_xattr:
+                        mopt->mount_opt &= ~OCFS2_MOUNT_NOUSERXATTR;
+                        break;
+                case Opt_nouser_xattr:
+                        mopt->mount_opt |= OCFS2_MOUNT_NOUSERXATTR;
+                        break;
                case Opt_atime_quantum:
                        if (match_int(&args[0], &option)) {
                                status = 0;
@@ -873,7 +897,7 @@ static int ocfs2_parse_options(struct super_block *sb,
                        if (option < 0)
                                return 0;
                        if (option == 0)
-                                option = JBD_DEFAULT_MAX_COMMIT_AGE;
+                                option = JBD2_DEFAULT_MAX_COMMIT_AGE;
                        mopt->commit_interval = HZ * option;
                        break;
                case Opt_localalloc:
@@ -918,6 +942,9 @@ static int ocfs2_parse_options(struct super_block *sb,
                               OCFS2_STACK_LABEL_LEN);
                        mopt->cluster_stack[OCFS2_STACK_LABEL_LEN] = '\0';
                        break;
+                case Opt_inode64:
+                        mopt->mount_opt |= OCFS2_MOUNT_INODE64;
+                        break;
                default:
                        mlog(ML_ERROR,
                             "Unrecognized mount option \"%s\" "
@@ -938,6 +965,7 @@ static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
 {
        struct ocfs2_super *osb = OCFS2_SB(mnt->mnt_sb);
        unsigned long opts = osb->s_mount_opt;
+        unsigned int local_alloc_megs;
        if (opts & OCFS2_MOUNT_HB_LOCAL)
                seq_printf(s, ",_netdev,heartbeat=local");
@@ -970,8 +998,9 @@ static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
                seq_printf(s, ",commit=%u",
                           (unsigned) (osb->osb_commit_interval / HZ));
-        if (osb->local_alloc_size != OCFS2_DEFAULT_LOCAL_ALLOC_SIZE)
+        local_alloc_megs = osb->local_alloc_bits >> (20 - osb->s_clustersize_bits);
-                seq_printf(s, ",localalloc=%d", osb->local_alloc_size);
+        if (local_alloc_megs != OCFS2_DEFAULT_LOCAL_ALLOC_SIZE)
+                seq_printf(s, ",localalloc=%d", local_alloc_megs);
        if (opts & OCFS2_MOUNT_LOCALFLOCKS)
                seq_printf(s, ",localflocks,");
@@ -980,6 +1009,14 @@ static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
                seq_printf(s, ",cluster_stack=%.*s", OCFS2_STACK_LABEL_LEN,
                           osb->osb_cluster_stack);
+        if (opts & OCFS2_MOUNT_NOUSERXATTR)
+                seq_printf(s, ",nouser_xattr");
+        else
+                seq_printf(s, ",user_xattr");
+        if (opts & OCFS2_MOUNT_INODE64)
+                seq_printf(s, ",inode64");
        return 0;
 }
@@ -1132,6 +1169,7 @@ static void ocfs2_inode_init_once(void *data)
        oi->ip_dir_start_lookup = 0;
        init_rwsem(&oi->ip_alloc_sem);
+        init_rwsem(&oi->ip_xattr_sem);
        mutex_init(&oi->ip_io_mutex);
        oi->ip_blkno = 0ULL;
@@ -1375,6 +1413,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
        sb->s_fs_info = osb;
        sb->s_op = &ocfs2_sops;
        sb->s_export_op = &ocfs2_export_ops;
+        sb->s_xattr = ocfs2_xattr_handlers;
        sb->s_time_gran = 1;
        sb->s_flags |= MS_NOATIME;
        /* this is needed to support O_LARGEFILE */
@@ -1421,8 +1460,12 @@ static int ocfs2_initialize_super(struct super_block *sb,
        osb->slot_num = OCFS2_INVALID_SLOT;
+        osb->s_xattr_inline_size = le16_to_cpu(
+                                        di->id2.i_super.s_xattr_inline_size);
        osb->local_alloc_state = OCFS2_LA_UNUSED;
        osb->local_alloc_bh = NULL;
+        INIT_DELAYED_WORK(&osb->la_enable_wq, ocfs2_la_enable_worker);
        init_waitqueue_head(&osb->osb_mount_event);
@@ -1568,6 +1611,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
        osb->first_cluster_group_blkno =
                le64_to_cpu(di->id2.i_super.s_first_cluster_group);
        osb->fs_generation = le32_to_cpu(di->i_fs_generation);
+        osb->uuid_hash = le32_to_cpu(di->id2.i_super.s_uuid_hash);
        mlog(0, "vol_label: %s\n", osb->vol_label);
        mlog(0, "uuid: %s\n", osb->uuid_str);
        mlog(0, "root_blkno=%llu, system_dir_blkno=%llu\n",
diff --git a/fs/ocfs2/symlink.c b/fs/ocfs2/symlink.c
index ba9dbb51d25b..cbd03dfdc7b9 100644
--- a/fs/ocfs2/symlink.c
+++ b/fs/ocfs2/symlink.c
@@ -50,6 +50,7 @@
 #include "inode.h"
 #include "journal.h"
 #include "symlink.h"
+#include "xattr.h"
 #include "buffer_head_io.h"
@@ -83,11 +84,7 @@ static char *ocfs2_fast_symlink_getlink(struct inode *inode,
        mlog_entry_void();
-        status = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+        status = ocfs2_read_block(inode, OCFS2_I(inode)->ip_blkno, bh);
-                                  OCFS2_I(inode)->ip_blkno,
-                                  bh,
-                                  OCFS2_BH_CACHED,
-                                  inode);
        if (status < 0) {
                mlog_errno(status);
                link = ERR_PTR(status);
@@ -157,8 +154,7 @@ bail:
                kunmap(page);
                page_cache_release(page);
        }
-        if (bh)
+        brelse(bh);
-                brelse(bh);
        return ERR_PTR(status);
 }
@@ -168,10 +164,18 @@ const struct inode_operations ocfs2_symlink_inode_operations = {
        .follow_link    = ocfs2_follow_link,
        .getattr        = ocfs2_getattr,
        .setattr        = ocfs2_setattr,
+        .setxattr       = generic_setxattr,
+        .getxattr       = generic_getxattr,
+        .listxattr      = ocfs2_listxattr,
+        .removexattr    = generic_removexattr,
 };
 const struct inode_operations ocfs2_fast_symlink_inode_operations = {
        .readlink       = ocfs2_readlink,
        .follow_link    = ocfs2_follow_link,
        .getattr        = ocfs2_getattr,
        .setattr        = ocfs2_setattr,
+        .setxattr       = generic_setxattr,
+        .getxattr       = generic_getxattr,
+        .listxattr      = ocfs2_listxattr,
+        .removexattr    = generic_removexattr,
 };
diff --git a/fs/ocfs2/uptodate.c b/fs/ocfs2/uptodate.c
index 4da8851f2b23..187b99ff0368 100644
--- a/fs/ocfs2/uptodate.c
+++ b/fs/ocfs2/uptodate.c
@@ -53,7 +53,11 @@
 #include <linux/highmem.h>
 #include <linux/buffer_head.h>
 #include <linux/rbtree.h>
-#include <linux/jbd.h>
+#ifndef CONFIG_OCFS2_COMPAT_JBD
+# include <linux/jbd2.h>
+#else
+# include <linux/jbd.h>
+#endif
 #define MLOG_MASK_PREFIX ML_UPTODATE
@@ -511,14 +515,10 @@ static void ocfs2_remove_metadata_tree(struct ocfs2_caching_info *ci,
        ci->ci_num_cached--;
 }
-/* Called when we remove a chunk of metadata from an inode. We don't
+static void ocfs2_remove_block_from_cache(struct inode *inode,
- * bother reverting things to an inlined array in the case of a remove
+                                          sector_t block)
- * which moves us back under the limit. */
-void ocfs2_remove_from_cache(struct inode *inode,
-                             struct buffer_head *bh)
 {
        int index;
-        sector_t block = bh->b_blocknr;
        struct ocfs2_meta_cache_item *item = NULL;
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
        struct ocfs2_caching_info *ci = &oi->ip_metadata_cache;
@@ -544,6 +544,30 @@ void ocfs2_remove_from_cache(struct inode *inode,
                kmem_cache_free(ocfs2_uptodate_cachep, item);
 }
+/*
+ * Called when we remove a chunk of metadata from an inode. We don't
+ * bother reverting things to an inlined array in the case of a remove
+ * which moves us back under the limit.
+ */
+void ocfs2_remove_from_cache(struct inode *inode,
+                             struct buffer_head *bh)
+{
+        sector_t block = bh->b_blocknr;
+        ocfs2_remove_block_from_cache(inode, block);
+}
+/* Called when we remove xattr clusters from an inode. */
+void ocfs2_remove_xattr_clusters_from_cache(struct inode *inode,
+                                            sector_t block,
+                                            u32 c_len)
+{
+        unsigned int i, b_len = ocfs2_clusters_to_blocks(inode->i_sb, 1) * c_len;
+        for (i = 0; i < b_len; i++, block++)
+                ocfs2_remove_block_from_cache(inode, block);
+}
 int __init init_ocfs2_uptodate_cache(void)
 {
        ocfs2_uptodate_cachep = kmem_cache_create("ocfs2_uptodate",
diff --git a/fs/ocfs2/uptodate.h b/fs/ocfs2/uptodate.h
index 2e73206059a8..531b4b3a0c47 100644
--- a/fs/ocfs2/uptodate.h
+++ b/fs/ocfs2/uptodate.h
@@ -40,6 +40,9 @@ void ocfs2_set_new_buffer_uptodate(struct inode *inode,
                                   struct buffer_head *bh);
 void ocfs2_remove_from_cache(struct inode *inode,
                             struct buffer_head *bh);
+void ocfs2_remove_xattr_clusters_from_cache(struct inode *inode,
+                                            sector_t block,
+                                            u32 c_len);
 int ocfs2_buffer_read_ahead(struct inode *inode,
                            struct buffer_head *bh);
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
new file mode 100644
index 000000000000..c25780a70dfd
--- /dev/null
+++ b/fs/ocfs2/xattr.c
@@ -0,0 +1,4834 @@
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * xattr.c
+ *
+ * Copyright (C) 2008 Oracle.  All rights reserved.
+ *
+ * CREDITS:
+ * Lots of code in this file is taken from ext3.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+#include <linux/capability.h>
+#include <linux/fs.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/highmem.h>
+#include <linux/pagemap.h>
+#include <linux/uio.h>
+#include <linux/sched.h>
+#include <linux/splice.h>
+#include <linux/mount.h>
+#include <linux/writeback.h>
+#include <linux/falloc.h>
+#include <linux/sort.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#define MLOG_MASK_PREFIX ML_XATTR
+#include <cluster/masklog.h>
+#include "ocfs2.h"
+#include "alloc.h"
+#include "dlmglue.h"
+#include "file.h"
+#include "symlink.h"
+#include "sysfile.h"
+#include "inode.h"
+#include "journal.h"
+#include "ocfs2_fs.h"
+#include "suballoc.h"
+#include "uptodate.h"
+#include "buffer_head_io.h"
+#include "super.h"
+#include "xattr.h"
+struct ocfs2_xattr_def_value_root {
+        struct ocfs2_xattr_value_root   xv;
+        struct ocfs2_extent_rec         er;
+};
+struct ocfs2_xattr_bucket {
+        struct buffer_head *bhs[OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET];
+        struct ocfs2_xattr_header *xh;
+};
+#define OCFS2_XATTR_ROOT_SIZE   (sizeof(struct ocfs2_xattr_def_value_root))
+#define OCFS2_XATTR_INLINE_SIZE 80
+static struct ocfs2_xattr_def_value_root def_xv = {
+        .xv.xr_list.l_count = cpu_to_le16(1),
+};
+struct xattr_handler *ocfs2_xattr_handlers[] = {
+        &ocfs2_xattr_user_handler,
+        &ocfs2_xattr_trusted_handler,
+        NULL
+};
+static struct xattr_handler *ocfs2_xattr_handler_map[] = {
+        [OCFS2_XATTR_INDEX_USER]        = &ocfs2_xattr_user_handler,
+        [OCFS2_XATTR_INDEX_TRUSTED]     = &ocfs2_xattr_trusted_handler,
+};
+struct ocfs2_xattr_info {
+        int name_index;
+        const char *name;
+        const void *value;
+        size_t value_len;
+};
+struct ocfs2_xattr_search {
+        struct buffer_head *inode_bh;
+        /*
+         * xattr_bh point to the block buffer head which has extended attribute
+         * when extended attribute in inode, xattr_bh is equal to inode_bh.
+         */
+        struct buffer_head *xattr_bh;
+        struct ocfs2_xattr_header *header;
+        struct ocfs2_xattr_bucket bucket;
+        void *base;
+        void *end;
+        struct ocfs2_xattr_entry *here;
+        int not_found;
+};
+static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
+                                             struct ocfs2_xattr_header *xh,
+                                             int index,
+                                             int *block_off,
+                                             int *new_offset);
+static int ocfs2_xattr_index_block_find(struct inode *inode,
+                                        struct buffer_head *root_bh,
+                                        int name_index,
+                                        const char *name,
+                                        struct ocfs2_xattr_search *xs);
+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
+                                        struct ocfs2_xattr_tree_root *xt,
+                                        char *buffer,
+                                        size_t buffer_size);
+static int ocfs2_xattr_create_index_block(struct inode *inode,
+                                          struct ocfs2_xattr_search *xs);
+static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
+                                             struct ocfs2_xattr_info *xi,
+                                             struct ocfs2_xattr_search *xs);
+static int ocfs2_delete_xattr_index_block(struct inode *inode,
+                                          struct buffer_head *xb_bh);
+static inline const char *ocfs2_xattr_prefix(int name_index)
+{
+        struct xattr_handler *handler = NULL;
+        if (name_index > 0 && name_index < OCFS2_XATTR_MAX)
+                handler = ocfs2_xattr_handler_map[name_index];
+        return handler ? handler->prefix : NULL;
+}
+static u32 ocfs2_xattr_name_hash(struct inode *inode,
+                                 const char *name,
+                                 int name_len)
+{
+        /* Get hash value of uuid from super block */
+        u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash;
+        int i;
+        /* hash extended attribute name */
+        for (i = 0; i < name_len; i++) {
+                hash = (hash << OCFS2_HASH_SHIFT) ^
+                       (hash >> (8*sizeof(hash) - OCFS2_HASH_SHIFT)) ^
+                       *name++;
+        }
+        return hash;
+}
+/*
+ * ocfs2_xattr_hash_entry()
+ *
+ * Compute the hash of an extended attribute.
+ */
+static void ocfs2_xattr_hash_entry(struct inode *inode,
+                                   struct ocfs2_xattr_header *header,
+                                   struct ocfs2_xattr_entry *entry)
+{
+        u32 hash = 0;
+        char *name = (char *)header + le16_to_cpu(entry->xe_name_offset);
+        hash = ocfs2_xattr_name_hash(inode, name, entry->xe_name_len);
+        entry->xe_name_hash = cpu_to_le32(hash);
+        return;
+}
+static int ocfs2_xattr_extend_allocation(struct inode *inode,
+                                         u32 clusters_to_add,
+                                         struct buffer_head *xattr_bh,
+                                         struct ocfs2_xattr_value_root *xv)
+{
+        int status = 0;
+        int restart_func = 0;
+        int credits = 0;
+        handle_t *handle = NULL;
+        struct ocfs2_alloc_context *data_ac = NULL;
+        struct ocfs2_alloc_context *meta_ac = NULL;
+        enum ocfs2_alloc_restarted why;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        u32 prev_clusters, logical_start = le32_to_cpu(xv->xr_clusters);
+        struct ocfs2_extent_tree et;
+        mlog(0, "(clusters_to_add for xattr= %u)\n", clusters_to_add);
+        ocfs2_init_xattr_value_extent_tree(&et, inode, xattr_bh, xv);
+restart_all:
+        status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
+                                       &data_ac, &meta_ac);
+        if (status) {
+                mlog_errno(status);
+                goto leave;
+        }
+        credits = ocfs2_calc_extend_credits(osb->sb, et.et_root_el,
+                                            clusters_to_add);
+        handle = ocfs2_start_trans(osb, credits);
+        if (IS_ERR(handle)) {
+                status = PTR_ERR(handle);
+                handle = NULL;
+                mlog_errno(status);
+                goto leave;
+        }
+restarted_transaction:
+        status = ocfs2_journal_access(handle, inode, xattr_bh,
+                                      OCFS2_JOURNAL_ACCESS_WRITE);
+        if (status < 0) {
+                mlog_errno(status);
+                goto leave;
+        }
+        prev_clusters = le32_to_cpu(xv->xr_clusters);
+        status = ocfs2_add_clusters_in_btree(osb,
+                                             inode,
+                                             &logical_start,
+                                             clusters_to_add,
+                                             0,
+                                             &et,
+                                             handle,
+                                             data_ac,
+                                             meta_ac,
+                                             &why);
+        if ((status < 0) && (status != -EAGAIN)) {
+                if (status != -ENOSPC)
+                        mlog_errno(status);
+                goto leave;
+        }
+        status = ocfs2_journal_dirty(handle, xattr_bh);
+        if (status < 0) {
+                mlog_errno(status);
+                goto leave;
+        }
+        clusters_to_add -= le32_to_cpu(xv->xr_clusters) - prev_clusters;
+        if (why != RESTART_NONE && clusters_to_add) {
+                if (why == RESTART_META) {
+                        mlog(0, "restarting function.\n");
+                        restart_func = 1;
+                } else {
+                        BUG_ON(why != RESTART_TRANS);
+                        mlog(0, "restarting transaction.\n");
+                        /* TODO: This can be more intelligent. */
+                        credits = ocfs2_calc_extend_credits(osb->sb,
+                                                            et.et_root_el,
+                                                            clusters_to_add);
+                        status = ocfs2_extend_trans(handle, credits);
+                        if (status < 0) {
+                                /* handle still has to be committed at
+                                 * this point. */
+                                status = -ENOMEM;
+                                mlog_errno(status);
+                                goto leave;
+                        }
+                        goto restarted_transaction;
+                }
+        }
+leave:
+        if (handle) {
+                ocfs2_commit_trans(osb, handle);
+                handle = NULL;
+        }
+        if (data_ac) {
+                ocfs2_free_alloc_context(data_ac);
+                data_ac = NULL;
+        }
+        if (meta_ac) {
+                ocfs2_free_alloc_context(meta_ac);
+                meta_ac = NULL;
+        }
+        if ((!status) && restart_func) {
+                restart_func = 0;
+                goto restart_all;
+        }
+        return status;
+}
+static int __ocfs2_remove_xattr_range(struct inode *inode,
+                                      struct buffer_head *root_bh,
+                                      struct ocfs2_xattr_value_root *xv,
+                                      u32 cpos, u32 phys_cpos, u32 len,
+                                      struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret;
+        u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct inode *tl_inode = osb->osb_tl_inode;
+        handle_t *handle;
+        struct ocfs2_alloc_context *meta_ac = NULL;
+        struct ocfs2_extent_tree et;
+        ocfs2_init_xattr_value_extent_tree(&et, inode, root_bh, xv);
+        ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
+        if (ret) {
+                mlog_errno(ret);
+                return ret;
+        }
+        mutex_lock(&tl_inode->i_mutex);
+        if (ocfs2_truncate_log_needs_flush(osb)) {
+                ret = __ocfs2_flush_truncate_log(osb);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, root_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac,
+                                  dealloc);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        le32_add_cpu(&xv->xr_clusters, -len);
+        ret = ocfs2_journal_dirty(handle, root_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        ret = ocfs2_truncate_log_append(osb, handle, phys_blkno, len);
+        if (ret)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        mutex_unlock(&tl_inode->i_mutex);
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+        return ret;
+}
+static int ocfs2_xattr_shrink_size(struct inode *inode,
+                                   u32 old_clusters,
+                                   u32 new_clusters,
+                                   struct buffer_head *root_bh,
+                                   struct ocfs2_xattr_value_root *xv)
+{
+        int ret = 0;
+        u32 trunc_len, cpos, phys_cpos, alloc_size;
+        u64 block;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_cached_dealloc_ctxt dealloc;
+        ocfs2_init_dealloc_ctxt(&dealloc);
+        if (old_clusters <= new_clusters)
+                return 0;
+        cpos = new_clusters;
+        trunc_len = old_clusters - new_clusters;
+        while (trunc_len) {
+                ret = ocfs2_xattr_get_clusters(inode, cpos, &phys_cpos,
+                                               &alloc_size, &xv->xr_list);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                if (alloc_size > trunc_len)
+                        alloc_size = trunc_len;
+                ret = __ocfs2_remove_xattr_range(inode, root_bh, xv, cpos,
+                                                 phys_cpos, alloc_size,
+                                                 &dealloc);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
+                ocfs2_remove_xattr_clusters_from_cache(inode, block,
+                                                       alloc_size);
+                cpos += alloc_size;
+                trunc_len -= alloc_size;
+        }
+out:
+        ocfs2_schedule_truncate_log_flush(osb, 1);
+        ocfs2_run_deallocs(osb, &dealloc);
+        return ret;
+}
+static int ocfs2_xattr_value_truncate(struct inode *inode,
+                                      struct buffer_head *root_bh,
+                                      struct ocfs2_xattr_value_root *xv,
+                                      int len)
+{
+        int ret;
+        u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len);
+        u32 old_clusters = le32_to_cpu(xv->xr_clusters);
+        if (new_clusters == old_clusters)
+                return 0;
+        if (new_clusters > old_clusters)
+                ret = ocfs2_xattr_extend_allocation(inode,
+                                                    new_clusters - old_clusters,
+                                                    root_bh, xv);
+        else
+                ret = ocfs2_xattr_shrink_size(inode,
+                                              old_clusters, new_clusters,
+                                              root_bh, xv);
+        return ret;
+}
+static int ocfs2_xattr_list_entry(char *buffer, size_t size,
+                                  size_t *result, const char *prefix,
+                                  const char *name, int name_len)
+{
+        char *p = buffer + *result;
+        int prefix_len = strlen(prefix);
+        int total_len = prefix_len + name_len + 1;
+        *result += total_len;
+        /* we are just looking for how big our buffer needs to be */
+        if (!size)
+                return 0;
+        if (*result > size)
+                return -ERANGE;
+        memcpy(p, prefix, prefix_len);
+        memcpy(p + prefix_len, name, name_len);
+        p[prefix_len + name_len] = '\0';
+        return 0;
+}
+static int ocfs2_xattr_list_entries(struct inode *inode,
+                                    struct ocfs2_xattr_header *header,
+                                    char *buffer, size_t buffer_size)
+{
+        size_t result = 0;
+        int i, type, ret;
+        const char *prefix, *name;
+        for (i = 0 ; i < le16_to_cpu(header->xh_count); i++) {
+                struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
+                type = ocfs2_xattr_get_type(entry);
+                prefix = ocfs2_xattr_prefix(type);
+                if (prefix) {
+                        name = (const char *)header +
+                                le16_to_cpu(entry->xe_name_offset);
+                        ret = ocfs2_xattr_list_entry(buffer, buffer_size,
+                                                     &result, prefix, name,
+                                                     entry->xe_name_len);
+                        if (ret)
+                                return ret;
+                }
+        }
+        return result;
+}
+static int ocfs2_xattr_ibody_list(struct inode *inode,
+                                  struct ocfs2_dinode *di,
+                                  char *buffer,
+                                  size_t buffer_size)
+{
+        struct ocfs2_xattr_header *header = NULL;
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        int ret = 0;
+        if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
+                return ret;
+        header = (struct ocfs2_xattr_header *)
+                 ((void *)di + inode->i_sb->s_blocksize -
+                 le16_to_cpu(di->i_xattr_inline_size));
+        ret = ocfs2_xattr_list_entries(inode, header, buffer, buffer_size);
+        return ret;
+}
+static int ocfs2_xattr_block_list(struct inode *inode,
+                                  struct ocfs2_dinode *di,
+                                  char *buffer,
+                                  size_t buffer_size)
+{
+        struct buffer_head *blk_bh = NULL;
+        struct ocfs2_xattr_block *xb;
+        int ret = 0;
+        if (!di->i_xattr_loc)
+                return ret;
+        ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        /*Verify the signature of xattr block*/
+        if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
+                   strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
+                ret = -EFAULT;
+                goto cleanup;
+        }
+        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
+        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
+                struct ocfs2_xattr_header *header = &xb->xb_attrs.xb_header;
+                ret = ocfs2_xattr_list_entries(inode, header,
+                                               buffer, buffer_size);
+        } else {
+                struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
+                ret = ocfs2_xattr_tree_list_index_block(inode, xt,
+                                                   buffer, buffer_size);
+        }
+cleanup:
+        brelse(blk_bh);
+        return ret;
+}
+ssize_t ocfs2_listxattr(struct dentry *dentry,
+                        char *buffer,
+                        size_t size)
+{
+        int ret = 0, i_ret = 0, b_ret = 0;
+        struct buffer_head *di_bh = NULL;
+        struct ocfs2_dinode *di = NULL;
+        struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode);
+        if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb)))
+                return -EOPNOTSUPP;
+        if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
+                return ret;
+        ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        di = (struct ocfs2_dinode *)di_bh->b_data;
+        down_read(&oi->ip_xattr_sem);
+        i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size);
+        if (i_ret < 0)
+                b_ret = 0;
+        else {
+                if (buffer) {
+                        buffer += i_ret;
+                        size -= i_ret;
+                }
+                b_ret = ocfs2_xattr_block_list(dentry->d_inode, di,
+                                               buffer, size);
+                if (b_ret < 0)
+                        i_ret = 0;
+        }
+        up_read(&oi->ip_xattr_sem);
+        ocfs2_inode_unlock(dentry->d_inode, 0);
+        brelse(di_bh);
+        return i_ret + b_ret;
+}
+static int ocfs2_xattr_find_entry(int name_index,
+                                  const char *name,
+                                  struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_xattr_entry *entry;
+        size_t name_len;
+        int i, cmp = 1;
+        if (name == NULL)
+                return -EINVAL;
+        name_len = strlen(name);
+        entry = xs->here;
+        for (i = 0; i < le16_to_cpu(xs->header->xh_count); i++) {
+                cmp = name_index - ocfs2_xattr_get_type(entry);
+                if (!cmp)
+                        cmp = name_len - entry->xe_name_len;
+                if (!cmp)
+                        cmp = memcmp(name, (xs->base +
+                                     le16_to_cpu(entry->xe_name_offset)),
+                                     name_len);
+                if (cmp == 0)
+                        break;
+                entry += 1;
+        }
+        xs->here = entry;
+        return cmp ? -ENODATA : 0;
+}
+static int ocfs2_xattr_get_value_outside(struct inode *inode,
+                                         struct ocfs2_xattr_value_root *xv,
+                                         void *buffer,
+                                         size_t len)
+{
+        u32 cpos, p_cluster, num_clusters, bpc, clusters;
+        u64 blkno;
+        int i, ret = 0;
+        size_t cplen, blocksize;
+        struct buffer_head *bh = NULL;
+        struct ocfs2_extent_list *el;
+        el = &xv->xr_list;
+        clusters = le32_to_cpu(xv->xr_clusters);
+        bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+        blocksize = inode->i_sb->s_blocksize;
+        cpos = 0;
+        while (cpos < clusters) {
+                ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
+                                               &num_clusters, el);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
+                /* Copy ocfs2_xattr_value */
+                for (i = 0; i < num_clusters * bpc; i++, blkno++) {
+                        ret = ocfs2_read_block(inode, blkno, &bh);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                        cplen = len >= blocksize ? blocksize : len;
+                        memcpy(buffer, bh->b_data, cplen);
+                        len -= cplen;
+                        buffer += cplen;
+                        brelse(bh);
+                        bh = NULL;
+                        if (len == 0)
+                                break;
+                }
+                cpos += num_clusters;
+        }
+out:
+        return ret;
+}
+static int ocfs2_xattr_ibody_get(struct inode *inode,
+                                 int name_index,
+                                 const char *name,
+                                 void *buffer,
+                                 size_t buffer_size,
+                                 struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        struct ocfs2_xattr_value_root *xv;
+        size_t size;
+        int ret = 0;
+        if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL))
+                return -ENODATA;
+        xs->end = (void *)di + inode->i_sb->s_blocksize;
+        xs->header = (struct ocfs2_xattr_header *)
+                        (xs->end - le16_to_cpu(di->i_xattr_inline_size));
+        xs->base = (void *)xs->header;
+        xs->here = xs->header->xh_entries;
+        ret = ocfs2_xattr_find_entry(name_index, name, xs);
+        if (ret)
+                return ret;
+        size = le64_to_cpu(xs->here->xe_value_size);
+        if (buffer) {
+                if (size > buffer_size)
+                        return -ERANGE;
+                if (ocfs2_xattr_is_local(xs->here)) {
+                        memcpy(buffer, (void *)xs->base +
+                               le16_to_cpu(xs->here->xe_name_offset) +
+                               OCFS2_XATTR_SIZE(xs->here->xe_name_len), size);
+                } else {
+                        xv = (struct ocfs2_xattr_value_root *)
+                                (xs->base + le16_to_cpu(
+                                 xs->here->xe_name_offset) +
+                                OCFS2_XATTR_SIZE(xs->here->xe_name_len));
+                        ret = ocfs2_xattr_get_value_outside(inode, xv,
+                                                            buffer, size);
+                        if (ret < 0) {
+                                mlog_errno(ret);
+                                return ret;
+                        }
+                }
+        }
+        return size;
+}
+static int ocfs2_xattr_block_get(struct inode *inode,
+                                 int name_index,
+                                 const char *name,
+                                 void *buffer,
+                                 size_t buffer_size,
+                                 struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        struct buffer_head *blk_bh = NULL;
+        struct ocfs2_xattr_block *xb;
+        struct ocfs2_xattr_value_root *xv;
+        size_t size;
+        int ret = -ENODATA, name_offset, name_len, block_off, i;
+        if (!di->i_xattr_loc)
+                return ret;
+        memset(&xs->bucket, 0, sizeof(xs->bucket));
+        ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        /*Verify the signature of xattr block*/
+        if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
+                   strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
+                ret = -EFAULT;
+                goto cleanup;
+        }
+        xs->xattr_bh = blk_bh;
+        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
+        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
+                xs->header = &xb->xb_attrs.xb_header;
+                xs->base = (void *)xs->header;
+                xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
+                xs->here = xs->header->xh_entries;
+                ret = ocfs2_xattr_find_entry(name_index, name, xs);
+        } else
+                ret = ocfs2_xattr_index_block_find(inode, blk_bh,
+                                                   name_index,
+                                                   name, xs);
+        if (ret)
+                goto cleanup;
+        size = le64_to_cpu(xs->here->xe_value_size);
+        if (buffer) {
+                ret = -ERANGE;
+                if (size > buffer_size)
+                        goto cleanup;
+                name_offset = le16_to_cpu(xs->here->xe_name_offset);
+                name_len = OCFS2_XATTR_SIZE(xs->here->xe_name_len);
+                i = xs->here - xs->header->xh_entries;
+                if (le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED) {
+                        ret = ocfs2_xattr_bucket_get_name_value(inode,
+                                                                xs->bucket.xh,
+                                                                i,
+                                                                &block_off,
+                                                                &name_offset);
+                        xs->base = xs->bucket.bhs[block_off]->b_data;
+                }
+                if (ocfs2_xattr_is_local(xs->here)) {
+                        memcpy(buffer, (void *)xs->base +
+                               name_offset + name_len, size);
+                } else {
+                        xv = (struct ocfs2_xattr_value_root *)
+                                (xs->base + name_offset + name_len);
+                        ret = ocfs2_xattr_get_value_outside(inode, xv,
+                                                            buffer, size);
+                        if (ret < 0) {
+                                mlog_errno(ret);
+                                goto cleanup;
+                        }
+                }
+        }
+        ret = size;
+cleanup:
+        for (i = 0; i < OCFS2_XATTR_MAX_BLOCKS_PER_BUCKET; i++)
+                brelse(xs->bucket.bhs[i]);
+        memset(&xs->bucket, 0, sizeof(xs->bucket));
+        brelse(blk_bh);
+        return ret;
+}
+/* ocfs2_xattr_get()
+ *
+ * Copy an extended attribute into the buffer provided.
+ * Buffer is NULL to compute the size of buffer required.
+ */
+int ocfs2_xattr_get(struct inode *inode,
+                    int name_index,
+                    const char *name,
+                    void *buffer,
+                    size_t buffer_size)
+{
+        int ret;
+        struct ocfs2_dinode *di = NULL;
+        struct buffer_head *di_bh = NULL;
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_xattr_search xis = {
+                .not_found = -ENODATA,
+        };
+        struct ocfs2_xattr_search xbs = {
+                .not_found = -ENODATA,
+        };
+        if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
+                return -EOPNOTSUPP;
+        if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
+                ret = -ENODATA;
+        ret = ocfs2_inode_lock(inode, &di_bh, 0);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        xis.inode_bh = xbs.inode_bh = di_bh;
+        di = (struct ocfs2_dinode *)di_bh->b_data;
+        down_read(&oi->ip_xattr_sem);
+        ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer,
+                                    buffer_size, &xis);
+        if (ret == -ENODATA)
+                ret = ocfs2_xattr_block_get(inode, name_index, name, buffer,
+                                            buffer_size, &xbs);
+        up_read(&oi->ip_xattr_sem);
+        ocfs2_inode_unlock(inode, 0);
+        brelse(di_bh);
+        return ret;
+}
+static int __ocfs2_xattr_set_value_outside(struct inode *inode,
+                                           struct ocfs2_xattr_value_root *xv,
+                                           const void *value,
+                                           int value_len)
+{
+        int ret = 0, i, cp_len, credits;
+        u16 blocksize = inode->i_sb->s_blocksize;
+        u32 p_cluster, num_clusters;
+        u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+        u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len);
+        u64 blkno;
+        struct buffer_head *bh = NULL;
+        handle_t *handle;
+        BUG_ON(clusters > le32_to_cpu(xv->xr_clusters));
+        credits = clusters * bpc;
+        handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), credits);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+        while (cpos < clusters) {
+                ret = ocfs2_xattr_get_clusters(inode, cpos, &p_cluster,
+                                               &num_clusters, &xv->xr_list);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster);
+                for (i = 0; i < num_clusters * bpc; i++, blkno++) {
+                        ret = ocfs2_read_block(inode, blkno, &bh);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out_commit;
+                        }
+                        ret = ocfs2_journal_access(handle,
+                                                   inode,
+                                                   bh,
+                                                   OCFS2_JOURNAL_ACCESS_WRITE);
+                        if (ret < 0) {
+                                mlog_errno(ret);
+                                goto out_commit;
+                        }
+                        cp_len = value_len > blocksize ? blocksize : value_len;
+                        memcpy(bh->b_data, value, cp_len);
+                        value_len -= cp_len;
+                        value += cp_len;
+                        if (cp_len < blocksize)
+                                memset(bh->b_data + cp_len, 0,
+                                       blocksize - cp_len);
+                        ret = ocfs2_journal_dirty(handle, bh);
+                        if (ret < 0) {
+                                mlog_errno(ret);
+                                goto out_commit;
+                        }
+                        brelse(bh);
+                        bh = NULL;
+                        /*
+                         * XXX: do we need to empty all the following
+                         * blocks in this cluster?
+                         */
+                        if (!value_len)
+                                break;
+                }
+                cpos += num_clusters;
+        }
+out_commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+out:
+        brelse(bh);
+        return ret;
+}
+static int ocfs2_xattr_cleanup(struct inode *inode,
+                               struct ocfs2_xattr_info *xi,
+                               struct ocfs2_xattr_search *xs,
+                               size_t offs)
+{
+        handle_t *handle = NULL;
+        int ret = 0;
+        size_t name_len = strlen(xi->name);
+        void *val = xs->base + offs;
+        size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
+        handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
+                                   OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        /* Decrease xattr count */
+        le16_add_cpu(&xs->header->xh_count, -1);
+        /* Remove the xattr entry and tree root which has already be set*/
+        memset((void *)xs->here, 0, sizeof(struct ocfs2_xattr_entry));
+        memset(val, 0, size);
+        ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
+        if (ret < 0)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+out:
+        return ret;
+}
+static int ocfs2_xattr_update_entry(struct inode *inode,
+                                    struct ocfs2_xattr_info *xi,
+                                    struct ocfs2_xattr_search *xs,
+                                    size_t offs)
+{
+        handle_t *handle = NULL;
+        int ret = 0;
+        handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
+                                   OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        xs->here->xe_name_offset = cpu_to_le16(offs);
+        xs->here->xe_value_size = cpu_to_le64(xi->value_len);
+        if (xi->value_len <= OCFS2_XATTR_INLINE_SIZE)
+                ocfs2_xattr_set_local(xs->here, 1);
+        else
+                ocfs2_xattr_set_local(xs->here, 0);
+        ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
+        ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
+        if (ret < 0)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+out:
+        return ret;
+}
+/*
+ * ocfs2_xattr_set_value_outside()
+ *
+ * Set large size value in B tree.
+ */
+static int ocfs2_xattr_set_value_outside(struct inode *inode,
+                                         struct ocfs2_xattr_info *xi,
+                                         struct ocfs2_xattr_search *xs,
+                                         size_t offs)
+{
+        size_t name_len = strlen(xi->name);
+        void *val = xs->base + offs;
+        struct ocfs2_xattr_value_root *xv = NULL;
+        size_t size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
+        int ret = 0;
+        memset(val, 0, size);
+        memcpy(val, xi->name, name_len);
+        xv = (struct ocfs2_xattr_value_root *)
+                (val + OCFS2_XATTR_SIZE(name_len));
+        xv->xr_clusters = 0;
+        xv->xr_last_eb_blk = 0;
+        xv->xr_list.l_tree_depth = 0;
+        xv->xr_list.l_count = cpu_to_le16(1);
+        xv->xr_list.l_next_free_rec = 0;
+        ret = ocfs2_xattr_value_truncate(inode, xs->xattr_bh, xv,
+                                         xi->value_len);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        ret = __ocfs2_xattr_set_value_outside(inode, xv, xi->value,
+                                              xi->value_len);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        ret = ocfs2_xattr_update_entry(inode, xi, xs, offs);
+        if (ret < 0)
+                mlog_errno(ret);
+        return ret;
+}
+/*
+ * ocfs2_xattr_set_entry_local()
+ *
+ * Set, replace or remove extended attribute in local.
+ */
+static void ocfs2_xattr_set_entry_local(struct inode *inode,
+                                        struct ocfs2_xattr_info *xi,
+                                        struct ocfs2_xattr_search *xs,
+                                        struct ocfs2_xattr_entry *last,
+                                        size_t min_offs)
+{
+        size_t name_len = strlen(xi->name);
+        int i;
+        if (xi->value && xs->not_found) {
+                /* Insert the new xattr entry. */
+                le16_add_cpu(&xs->header->xh_count, 1);
+                ocfs2_xattr_set_type(last, xi->name_index);
+                ocfs2_xattr_set_local(last, 1);
+                last->xe_name_len = name_len;
+        } else {
+                void *first_val;
+                void *val;
+                size_t offs, size;
+                first_val = xs->base + min_offs;
+                offs = le16_to_cpu(xs->here->xe_name_offset);
+                val = xs->base + offs;
+                if (le64_to_cpu(xs->here->xe_value_size) >
+                    OCFS2_XATTR_INLINE_SIZE)
+                        size = OCFS2_XATTR_SIZE(name_len) +
+                                OCFS2_XATTR_ROOT_SIZE;
+                else
+                        size = OCFS2_XATTR_SIZE(name_len) +
+                        OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
+                if (xi->value && size == OCFS2_XATTR_SIZE(name_len) +
+                                OCFS2_XATTR_SIZE(xi->value_len)) {
+                        /* The old and the new value have the
+                           same size. Just replace the value. */
+                        ocfs2_xattr_set_local(xs->here, 1);
+                        xs->here->xe_value_size = cpu_to_le64(xi->value_len);
+                        /* Clear value bytes. */
+                        memset(val + OCFS2_XATTR_SIZE(name_len),
+                               0,
+                               OCFS2_XATTR_SIZE(xi->value_len));
+                        memcpy(val + OCFS2_XATTR_SIZE(name_len),
+                               xi->value,
+                               xi->value_len);
+                        return;
+                }
+                /* Remove the old name+value. */
+                memmove(first_val + size, first_val, val - first_val);
+                memset(first_val, 0, size);
+                xs->here->xe_name_hash = 0;
+                xs->here->xe_name_offset = 0;
+                ocfs2_xattr_set_local(xs->here, 1);
+                xs->here->xe_value_size = 0;
+                min_offs += size;
+                /* Adjust all value offsets. */
+                last = xs->header->xh_entries;
+                for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
+                        size_t o = le16_to_cpu(last->xe_name_offset);
+                        if (o < offs)
+                                last->xe_name_offset = cpu_to_le16(o + size);
+                        last += 1;
+                }
+                if (!xi->value) {
+                        /* Remove the old entry. */
+                        last -= 1;
+                        memmove(xs->here, xs->here + 1,
+                                (void *)last - (void *)xs->here);
+                        memset(last, 0, sizeof(struct ocfs2_xattr_entry));
+                        le16_add_cpu(&xs->header->xh_count, -1);
+                }
+        }
+        if (xi->value) {
+                /* Insert the new name+value. */
+                size_t size = OCFS2_XATTR_SIZE(name_len) +
+                                OCFS2_XATTR_SIZE(xi->value_len);
+                void *val = xs->base + min_offs - size;
+                xs->here->xe_name_offset = cpu_to_le16(min_offs - size);
+                memset(val, 0, size);
+                memcpy(val, xi->name, name_len);
+                memcpy(val + OCFS2_XATTR_SIZE(name_len),
+                       xi->value,
+                       xi->value_len);
+                xs->here->xe_value_size = cpu_to_le64(xi->value_len);
+                ocfs2_xattr_set_local(xs->here, 1);
+                ocfs2_xattr_hash_entry(inode, xs->header, xs->here);
+        }
+        return;
+}
+/*
+ * ocfs2_xattr_set_entry()
+ *
+ * Set extended attribute entry into inode or block.
+ *
+ * If extended attribute value size > OCFS2_XATTR_INLINE_SIZE,
+ * We first insert tree root(ocfs2_xattr_value_root) with set_entry_local(),
+ * then set value in B tree with set_value_outside().
+ */
+static int ocfs2_xattr_set_entry(struct inode *inode,
+                                 struct ocfs2_xattr_info *xi,
+                                 struct ocfs2_xattr_search *xs,
+                                 int flag)
+{
+        struct ocfs2_xattr_entry *last;
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        size_t min_offs = xs->end - xs->base, name_len = strlen(xi->name);
+        size_t size_l = 0;
+        handle_t *handle = NULL;
+        int free, i, ret;
+        struct ocfs2_xattr_info xi_l = {
+                .name_index = xi->name_index,
+                .name = xi->name,
+                .value = xi->value,
+                .value_len = xi->value_len,
+        };
+        /* Compute min_offs, last and free space. */
+        last = xs->header->xh_entries;
+        for (i = 0 ; i < le16_to_cpu(xs->header->xh_count); i++) {
+                size_t offs = le16_to_cpu(last->xe_name_offset);
+                if (offs < min_offs)
+                        min_offs = offs;
+                last += 1;
+        }
+        free = min_offs - ((void *)last - xs->base) - sizeof(__u32);
+        if (free < 0)
+                return -EFAULT;
+        if (!xs->not_found) {
+                size_t size = 0;
+                if (ocfs2_xattr_is_local(xs->here))
+                        size = OCFS2_XATTR_SIZE(name_len) +
+                        OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
+                else
+                        size = OCFS2_XATTR_SIZE(name_len) +
+                                OCFS2_XATTR_ROOT_SIZE;
+                free += (size + sizeof(struct ocfs2_xattr_entry));
+        }
+        /* Check free space in inode or block */
+        if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
+                if (free < sizeof(struct ocfs2_xattr_entry) +
+                           OCFS2_XATTR_SIZE(name_len) +
+                           OCFS2_XATTR_ROOT_SIZE) {
+                        ret = -ENOSPC;
+                        goto out;
+                }
+                size_l = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_ROOT_SIZE;
+                xi_l.value = (void *)&def_xv;
+                xi_l.value_len = OCFS2_XATTR_ROOT_SIZE;
+        } else if (xi->value) {
+                if (free < sizeof(struct ocfs2_xattr_entry) +
+                           OCFS2_XATTR_SIZE(name_len) +
+                           OCFS2_XATTR_SIZE(xi->value_len)) {
+                        ret = -ENOSPC;
+                        goto out;
+                }
+        }
+        if (!xs->not_found) {
+                /* For existing extended attribute */
+                size_t size = OCFS2_XATTR_SIZE(name_len) +
+                        OCFS2_XATTR_SIZE(le64_to_cpu(xs->here->xe_value_size));
+                size_t offs = le16_to_cpu(xs->here->xe_name_offset);
+                void *val = xs->base + offs;
+                if (ocfs2_xattr_is_local(xs->here) && size == size_l) {
+                        /* Replace existing local xattr with tree root */
+                        ret = ocfs2_xattr_set_value_outside(inode, xi, xs,
+                                                            offs);
+                        if (ret < 0)
+                                mlog_errno(ret);
+                        goto out;
+                } else if (!ocfs2_xattr_is_local(xs->here)) {
+                        /* For existing xattr which has value outside */
+                        struct ocfs2_xattr_value_root *xv = NULL;
+                        xv = (struct ocfs2_xattr_value_root *)(val +
+                                OCFS2_XATTR_SIZE(name_len));
+                        if (xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
+                                /*
+                                 * If new value need set outside also,
+                                 * first truncate old value to new value,
+                                 * then set new value with set_value_outside().
+                                 */
+                                ret = ocfs2_xattr_value_truncate(inode,
+                                                                 xs->xattr_bh,
+                                                                 xv,
+                                                                 xi->value_len);
+                                if (ret < 0) {
+                                        mlog_errno(ret);
+                                        goto out;
+                                }
+                                ret = __ocfs2_xattr_set_value_outside(inode,
+                                                                xv,
+                                                                xi->value,
+                                                                xi->value_len);
+                                if (ret < 0) {
+                                        mlog_errno(ret);
+                                        goto out;
+                                }
+                                ret = ocfs2_xattr_update_entry(inode,
+                                                               xi,
+                                                               xs,
+                                                               offs);
+                                if (ret < 0)
+                                        mlog_errno(ret);
+                                goto out;
+                        } else {
+                                /*
+                                 * If new value need set in local,
+                                 * just trucate old value to zero.
+                                 */
+                                 ret = ocfs2_xattr_value_truncate(inode,
+                                                                 xs->xattr_bh,
+                                                                 xv,
+                                                                 0);
+                                if (ret < 0)
+                                        mlog_errno(ret);
+                        }
+                }
+        }
+        handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
+                                   OCFS2_INODE_UPDATE_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        if (!(flag & OCFS2_INLINE_XATTR_FL)) {
+                /* set extended attribute in external block. */
+                ret = ocfs2_extend_trans(handle,
+                                         OCFS2_INODE_UPDATE_CREDITS +
+                                         OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+        }
+        /*
+         * Set value in local, include set tree root in local.
+         * This is the first step for value size >INLINE_SIZE.
+         */
+        ocfs2_xattr_set_entry_local(inode, &xi_l, xs, last, min_offs);
+        if (!(flag & OCFS2_INLINE_XATTR_FL)) {
+                ret = ocfs2_journal_dirty(handle, xs->xattr_bh);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+        }
+        if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) &&
+            (flag & OCFS2_INLINE_XATTR_FL)) {
+                struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+                unsigned int xattrsize = osb->s_xattr_inline_size;
+                /*
+                 * Adjust extent record count or inline data size
+                 * to reserve space for extended attribute.
+                 */
+                if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
+                        struct ocfs2_inline_data *idata = &di->id2.i_data;
+                        le16_add_cpu(&idata->id_count, -xattrsize);
+                } else if (!(ocfs2_inode_is_fast_symlink(inode))) {
+                        struct ocfs2_extent_list *el = &di->id2.i_list;
+                        le16_add_cpu(&el->l_count, -(xattrsize /
+                                        sizeof(struct ocfs2_extent_rec)));
+                }
+                di->i_xattr_inline_size = cpu_to_le16(xattrsize);
+        }
+        /* Update xattr flag */
+        spin_lock(&oi->ip_lock);
+        oi->ip_dyn_features |= flag;
+        di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
+        spin_unlock(&oi->ip_lock);
+        /* Update inode ctime */
+        inode->i_ctime = CURRENT_TIME;
+        di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
+        di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
+        ret = ocfs2_journal_dirty(handle, xs->inode_bh);
+        if (ret < 0)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+        if (!ret && xi->value_len > OCFS2_XATTR_INLINE_SIZE) {
+                /*
+                 * Set value outside in B tree.
+                 * This is the second step for value size > INLINE_SIZE.
+                 */
+                size_t offs = le16_to_cpu(xs->here->xe_name_offset);
+                ret = ocfs2_xattr_set_value_outside(inode, xi, xs, offs);
+                if (ret < 0) {
+                        int ret2;
+                        mlog_errno(ret);
+                        /*
+                         * If set value outside failed, we have to clean
+                         * the junk tree root we have already set in local.
+                         */
+                        ret2 = ocfs2_xattr_cleanup(inode, xi, xs, offs);
+                        if (ret2 < 0)
+                                mlog_errno(ret2);
+                }
+        }
+out:
+        return ret;
+}
+static int ocfs2_remove_value_outside(struct inode*inode,
+                                      struct buffer_head *bh,
+                                      struct ocfs2_xattr_header *header)
+{
+        int ret = 0, i;
+        for (i = 0; i < le16_to_cpu(header->xh_count); i++) {
+                struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
+                if (!ocfs2_xattr_is_local(entry)) {
+                        struct ocfs2_xattr_value_root *xv;
+                        void *val;
+                        val = (void *)header +
+                                le16_to_cpu(entry->xe_name_offset);
+                        xv = (struct ocfs2_xattr_value_root *)
+                                (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
+                        ret = ocfs2_xattr_value_truncate(inode, bh, xv, 0);
+                        if (ret < 0) {
+                                mlog_errno(ret);
+                                return ret;
+                        }
+                }
+        }
+        return ret;
+}
+static int ocfs2_xattr_ibody_remove(struct inode *inode,
+                                    struct buffer_head *di_bh)
+{
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        struct ocfs2_xattr_header *header;
+        int ret;
+        header = (struct ocfs2_xattr_header *)
+                 ((void *)di + inode->i_sb->s_blocksize -
+                 le16_to_cpu(di->i_xattr_inline_size));
+        ret = ocfs2_remove_value_outside(inode, di_bh, header);
+        return ret;
+}
+static int ocfs2_xattr_block_remove(struct inode *inode,
+                                    struct buffer_head *blk_bh)
+{
+        struct ocfs2_xattr_block *xb;
+        int ret = 0;
+        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
+        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
+                struct ocfs2_xattr_header *header = &(xb->xb_attrs.xb_header);
+                ret = ocfs2_remove_value_outside(inode, blk_bh, header);
+        } else
+                ret = ocfs2_delete_xattr_index_block(inode, blk_bh);
+        return ret;
+}
+static int ocfs2_xattr_free_block(struct inode *inode,
+                                  u64 block)
+{
+        struct inode *xb_alloc_inode;
+        struct buffer_head *xb_alloc_bh = NULL;
+        struct buffer_head *blk_bh = NULL;
+        struct ocfs2_xattr_block *xb;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        handle_t *handle;
+        int ret = 0;
+        u64 blk, bg_blkno;
+        u16 bit;
+        ret = ocfs2_read_block(inode, block, &blk_bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+        /*Verify the signature of xattr block*/
+        if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
+                   strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
+                ret = -EFAULT;
+                goto out;
+        }
+        ret = ocfs2_xattr_block_remove(inode, blk_bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
+        blk = le64_to_cpu(xb->xb_blkno);
+        bit = le16_to_cpu(xb->xb_suballoc_bit);
+        bg_blkno = ocfs2_which_suballoc_group(blk, bit);
+        xb_alloc_inode = ocfs2_get_system_file_inode(osb,
+                                EXTENT_ALLOC_SYSTEM_INODE,
+                                le16_to_cpu(xb->xb_suballoc_slot));
+        if (!xb_alloc_inode) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+        mutex_lock(&xb_alloc_inode->i_mutex);
+        ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out_mutex;
+        }
+        handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out_unlock;
+        }
+        ret = ocfs2_free_suballoc_bits(handle, xb_alloc_inode, xb_alloc_bh,
+                                       bit, bg_blkno, 1);
+        if (ret < 0)
+                mlog_errno(ret);
+        ocfs2_commit_trans(osb, handle);
+out_unlock:
+        ocfs2_inode_unlock(xb_alloc_inode, 1);
+        brelse(xb_alloc_bh);
+out_mutex:
+        mutex_unlock(&xb_alloc_inode->i_mutex);
+        iput(xb_alloc_inode);
+out:
+        brelse(blk_bh);
+        return ret;
+}
+/*
+ * ocfs2_xattr_remove()
+ *
+ * Free extended attribute resources associated with this inode.
+ */
+int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh)
+{
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        handle_t *handle;
+        int ret;
+        if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
+                return 0;
+        if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
+                return 0;
+        if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
+                ret = ocfs2_xattr_ibody_remove(inode, di_bh);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        if (di->i_xattr_loc) {
+                ret = ocfs2_xattr_free_block(inode,
+                                             le64_to_cpu(di->i_xattr_loc));
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)),
+                                   OCFS2_INODE_UPDATE_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, di_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        di->i_xattr_loc = 0;
+        spin_lock(&oi->ip_lock);
+        oi->ip_dyn_features &= ~(OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL);
+        di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
+        spin_unlock(&oi->ip_lock);
+        ret = ocfs2_journal_dirty(handle, di_bh);
+        if (ret < 0)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+out:
+        return ret;
+}
+static int ocfs2_xattr_has_space_inline(struct inode *inode,
+                                        struct ocfs2_dinode *di)
+{
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size;
+        int free;
+        if (xattrsize < OCFS2_MIN_XATTR_INLINE_SIZE)
+                return 0;
+        if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
+                struct ocfs2_inline_data *idata = &di->id2.i_data;
+                free = le16_to_cpu(idata->id_count) - le64_to_cpu(di->i_size);
+        } else if (ocfs2_inode_is_fast_symlink(inode)) {
+                free = ocfs2_fast_symlink_chars(inode->i_sb) -
+                        le64_to_cpu(di->i_size);
+        } else {
+                struct ocfs2_extent_list *el = &di->id2.i_list;
+                free = (le16_to_cpu(el->l_count) -
+                        le16_to_cpu(el->l_next_free_rec)) *
+                        sizeof(struct ocfs2_extent_rec);
+        }
+        if (free >= xattrsize)
+                return 1;
+        return 0;
+}
+/*
+ * ocfs2_xattr_ibody_find()
+ *
+ * Find extended attribute in inode block and
+ * fill search info into struct ocfs2_xattr_search.
+ */
+static int ocfs2_xattr_ibody_find(struct inode *inode,
+                                  int name_index,
+                                  const char *name,
+                                  struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        int ret;
+        int has_space = 0;
+        if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
+                return 0;
+        if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
+                down_read(&oi->ip_alloc_sem);
+                has_space = ocfs2_xattr_has_space_inline(inode, di);
+                up_read(&oi->ip_alloc_sem);
+                if (!has_space)
+                        return 0;
+        }
+        xs->xattr_bh = xs->inode_bh;
+        xs->end = (void *)di + inode->i_sb->s_blocksize;
+        if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)
+                xs->header = (struct ocfs2_xattr_header *)
+                        (xs->end - le16_to_cpu(di->i_xattr_inline_size));
+        else
+                xs->header = (struct ocfs2_xattr_header *)
+                        (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size);
+        xs->base = (void *)xs->header;
+        xs->here = xs->header->xh_entries;
+        /* Find the named attribute. */
+        if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL) {
+                ret = ocfs2_xattr_find_entry(name_index, name, xs);
+                if (ret && ret != -ENODATA)
+                        return ret;
+                xs->not_found = ret;
+        }
+        return 0;
+}
+/*
+ * ocfs2_xattr_ibody_set()
+ *
+ * Set, replace or remove an extended attribute into inode block.
+ *
+ */
+static int ocfs2_xattr_ibody_set(struct inode *inode,
+                                 struct ocfs2_xattr_info *xi,
+                                 struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        int ret;
+        if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE)
+                return -ENOSPC;
+        down_write(&oi->ip_alloc_sem);
+        if (!(oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL)) {
+                if (!ocfs2_xattr_has_space_inline(inode, di)) {
+                        ret = -ENOSPC;
+                        goto out;
+                }
+        }
+        ret = ocfs2_xattr_set_entry(inode, xi, xs,
+                                (OCFS2_INLINE_XATTR_FL | OCFS2_HAS_XATTR_FL));
+out:
+        up_write(&oi->ip_alloc_sem);
+        return ret;
+}
+/*
+ * ocfs2_xattr_block_find()
+ *
+ * Find extended attribute in external block and
+ * fill search info into struct ocfs2_xattr_search.
+ */
+static int ocfs2_xattr_block_find(struct inode *inode,
+                                  int name_index,
+                                  const char *name,
+                                  struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        struct buffer_head *blk_bh = NULL;
+        struct ocfs2_xattr_block *xb;
+        int ret = 0;
+        if (!di->i_xattr_loc)
+                return ret;
+        ret = ocfs2_read_block(inode, le64_to_cpu(di->i_xattr_loc), &blk_bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        /*Verify the signature of xattr block*/
+        if (memcmp((void *)blk_bh->b_data, OCFS2_XATTR_BLOCK_SIGNATURE,
+                   strlen(OCFS2_XATTR_BLOCK_SIGNATURE))) {
+                        ret = -EFAULT;
+                        goto cleanup;
+        }
+        xs->xattr_bh = blk_bh;
+        xb = (struct ocfs2_xattr_block *)blk_bh->b_data;
+        if (!(le16_to_cpu(xb->xb_flags) & OCFS2_XATTR_INDEXED)) {
+                xs->header = &xb->xb_attrs.xb_header;
+                xs->base = (void *)xs->header;
+                xs->end = (void *)(blk_bh->b_data) + blk_bh->b_size;
+                xs->here = xs->header->xh_entries;
+                ret = ocfs2_xattr_find_entry(name_index, name, xs);
+        } else
+                ret = ocfs2_xattr_index_block_find(inode, blk_bh,
+                                                   name_index,
+                                                   name, xs);
+        if (ret && ret != -ENODATA) {
+                xs->xattr_bh = NULL;
+                goto cleanup;
+        }
+        xs->not_found = ret;
+        return 0;
+cleanup:
+        brelse(blk_bh);
+        return ret;
+}
+/*
+ * When all the xattrs are deleted from index btree, the ocfs2_xattr_tree
+ * will be erased and ocfs2_xattr_block will have its ocfs2_xattr_header
+ * re-initialized.
+ */
+static int ocfs2_restore_xattr_block(struct inode *inode,
+                                     struct ocfs2_xattr_search *xs)
+{
+        int ret;
+        handle_t *handle;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_xattr_block *xb =
+                (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
+        struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
+        u16 xb_flags = le16_to_cpu(xb->xb_flags);
+        BUG_ON(!(xb_flags & OCFS2_XATTR_INDEXED) ||
+                le16_to_cpu(el->l_next_free_rec) != 0);
+        handle = ocfs2_start_trans(osb, OCFS2_XATTR_BLOCK_UPDATE_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                handle = NULL;
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, xs->xattr_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize -
+               offsetof(struct ocfs2_xattr_block, xb_attrs));
+        xb->xb_flags = cpu_to_le16(xb_flags & ~OCFS2_XATTR_INDEXED);
+        ocfs2_journal_dirty(handle, xs->xattr_bh);
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        return ret;
+}
+/*
+ * ocfs2_xattr_block_set()
+ *
+ * Set, replace or remove an extended attribute into external block.
+ *
+ */
+static int ocfs2_xattr_block_set(struct inode *inode,
+                                 struct ocfs2_xattr_info *xi,
+                                 struct ocfs2_xattr_search *xs)
+{
+        struct buffer_head *new_bh = NULL;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_dinode *di =  (struct ocfs2_dinode *)xs->inode_bh->b_data;
+        struct ocfs2_alloc_context *meta_ac = NULL;
+        handle_t *handle = NULL;
+        struct ocfs2_xattr_block *xblk = NULL;
+        u16 suballoc_bit_start;
+        u32 num_got;
+        u64 first_blkno;
+        int ret;
+        if (!xs->xattr_bh) {
+                /*
+                 * Alloc one external block for extended attribute
+                 * outside of inode.
+                 */
+                ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                handle = ocfs2_start_trans(osb,
+                                           OCFS2_XATTR_BLOCK_CREATE_CREDITS);
+                if (IS_ERR(handle)) {
+                        ret = PTR_ERR(handle);
+                        mlog_errno(ret);
+                        goto out;
+                }
+                ret = ocfs2_journal_access(handle, inode, xs->inode_bh,
+                                           OCFS2_JOURNAL_ACCESS_CREATE);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1,
+                                           &suballoc_bit_start, &num_got,
+                                           &first_blkno);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                new_bh = sb_getblk(inode->i_sb, first_blkno);
+                ocfs2_set_new_buffer_uptodate(inode, new_bh);
+                ret = ocfs2_journal_access(handle, inode, new_bh,
+                                           OCFS2_JOURNAL_ACCESS_CREATE);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                /* Initialize ocfs2_xattr_block */
+                xs->xattr_bh = new_bh;
+                xblk = (struct ocfs2_xattr_block *)new_bh->b_data;
+                memset(xblk, 0, inode->i_sb->s_blocksize);
+                strcpy((void *)xblk, OCFS2_XATTR_BLOCK_SIGNATURE);
+                xblk->xb_suballoc_slot = cpu_to_le16(osb->slot_num);
+                xblk->xb_suballoc_bit = cpu_to_le16(suballoc_bit_start);
+                xblk->xb_fs_generation = cpu_to_le32(osb->fs_generation);
+                xblk->xb_blkno = cpu_to_le64(first_blkno);
+                xs->header = &xblk->xb_attrs.xb_header;
+                xs->base = (void *)xs->header;
+                xs->end = (void *)xblk + inode->i_sb->s_blocksize;
+                xs->here = xs->header->xh_entries;
+                ret = ocfs2_journal_dirty(handle, new_bh);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                di->i_xattr_loc = cpu_to_le64(first_blkno);
+                ret = ocfs2_journal_dirty(handle, xs->inode_bh);
+                if (ret < 0)
+                        mlog_errno(ret);
+out_commit:
+                ocfs2_commit_trans(osb, handle);
+out:
+                if (meta_ac)
+                        ocfs2_free_alloc_context(meta_ac);
+                if (ret < 0)
+                        return ret;
+        } else
+                xblk = (struct ocfs2_xattr_block *)xs->xattr_bh->b_data;
+        if (!(le16_to_cpu(xblk->xb_flags) & OCFS2_XATTR_INDEXED)) {
+                /* Set extended attribute into external block */
+                ret = ocfs2_xattr_set_entry(inode, xi, xs, OCFS2_HAS_XATTR_FL);
+                if (!ret || ret != -ENOSPC)
+                        goto end;
+                ret = ocfs2_xattr_create_index_block(inode, xs);
+                if (ret)
+                        goto end;
+        }
+        ret = ocfs2_xattr_set_entry_index_block(inode, xi, xs);
+        if (!ret && xblk->xb_attrs.xb_root.xt_list.l_next_free_rec == 0)
+                ret = ocfs2_restore_xattr_block(inode, xs);
+end:
+        return ret;
+}
+/*
+ * ocfs2_xattr_set()
+ *
+ * Set, replace or remove an extended attribute for this inode.
+ * value is NULL to remove an existing extended attribute, else either
+ * create or replace an extended attribute.
+ */
+int ocfs2_xattr_set(struct inode *inode,
+                    int name_index,
+                    const char *name,
+                    const void *value,
+                    size_t value_len,
+                    int flags)
+{
+        struct buffer_head *di_bh = NULL;
+        struct ocfs2_dinode *di;
+        int ret;
+        u16 i, blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        struct ocfs2_xattr_info xi = {
+                .name_index = name_index,
+                .name = name,
+                .value = value,
+                .value_len = value_len,
+        };
+        struct ocfs2_xattr_search xis = {
+                .not_found = -ENODATA,
+        };
+        struct ocfs2_xattr_search xbs = {
+                .not_found = -ENODATA,
+        };
+        if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb)))
+                return -EOPNOTSUPP;
+        ret = ocfs2_inode_lock(inode, &di_bh, 1);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+        xis.inode_bh = xbs.inode_bh = di_bh;
+        di = (struct ocfs2_dinode *)di_bh->b_data;
+        down_write(&OCFS2_I(inode)->ip_xattr_sem);
+        /*
+         * Scan inode and external block to find the same name
+         * extended attribute and collect search infomation.
+         */
+        ret = ocfs2_xattr_ibody_find(inode, name_index, name, &xis);
+        if (ret)
+                goto cleanup;
+        if (xis.not_found) {
+                ret = ocfs2_xattr_block_find(inode, name_index, name, &xbs);
+                if (ret)
+                        goto cleanup;
+        }
+        if (xis.not_found && xbs.not_found) {
+                ret = -ENODATA;
+                if (flags & XATTR_REPLACE)
+                        goto cleanup;
+                ret = 0;
+                if (!value)
+                        goto cleanup;
+        } else {
+                ret = -EEXIST;
+                if (flags & XATTR_CREATE)
+                        goto cleanup;
+        }
+        if (!value) {
+                /* Remove existing extended attribute */
+                if (!xis.not_found)
+                        ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
+                else if (!xbs.not_found)
+                        ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
+        } else {
+                /* We always try to set extended attribute into inode first*/
+                ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
+                if (!ret && !xbs.not_found) {
+                        /*
+                         * If succeed and that extended attribute existing in
+                         * external block, then we will remove it.
+                         */
+                        xi.value = NULL;
+                        xi.value_len = 0;
+                        ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
+                } else if (ret == -ENOSPC) {
+                        if (di->i_xattr_loc && !xbs.xattr_bh) {
+                                ret = ocfs2_xattr_block_find(inode, name_index,
+                                                             name, &xbs);
+                                if (ret)
+                                        goto cleanup;
+                        }
+                        /*
+                         * If no space in inode, we will set extended attribute
+                         * into external block.
+                         */
+                        ret = ocfs2_xattr_block_set(inode, &xi, &xbs);
+                        if (ret)
+                                goto cleanup;
+                        if (!xis.not_found) {
+                                /*
+                                 * If succeed and that extended attribute
+                                 * existing in inode, we will remove it.
+                                 */
+                                xi.value = NULL;
+                                xi.value_len = 0;
+                                ret = ocfs2_xattr_ibody_set(inode, &xi, &xis);
+                        }
+                }
+        }
+cleanup:
+        up_write(&OCFS2_I(inode)->ip_xattr_sem);
+        ocfs2_inode_unlock(inode, 1);
+        brelse(di_bh);
+        brelse(xbs.xattr_bh);
+        for (i = 0; i < blk_per_bucket; i++)
+                brelse(xbs.bucket.bhs[i]);
+        return ret;
+}
+/*
+ * Find the xattr extent rec which may contains name_hash.
+ * e_cpos will be the first name hash of the xattr rec.
+ * el must be the ocfs2_xattr_header.xb_attrs.xb_root.xt_list.
+ */
+static int ocfs2_xattr_get_rec(struct inode *inode,
+                               u32 name_hash,
+                               u64 *p_blkno,
+                               u32 *e_cpos,
+                               u32 *num_clusters,
+                               struct ocfs2_extent_list *el)
+{
+        int ret = 0, i;
+        struct buffer_head *eb_bh = NULL;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_extent_rec *rec = NULL;
+        u64 e_blkno = 0;
+        if (el->l_tree_depth) {
+                ret = ocfs2_find_leaf(inode, el, name_hash, &eb_bh);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                eb = (struct ocfs2_extent_block *) eb_bh->b_data;
+                el = &eb->h_list;
+                if (el->l_tree_depth) {
+                        ocfs2_error(inode->i_sb,
+                                    "Inode %lu has non zero tree depth in "
+                                    "xattr tree block %llu\n", inode->i_ino,
+                                    (unsigned long long)eb_bh->b_blocknr);
+                        ret = -EROFS;
+                        goto out;
+                }
+        }
+        for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
+                rec = &el->l_recs[i];
+                if (le32_to_cpu(rec->e_cpos) <= name_hash) {
+                        e_blkno = le64_to_cpu(rec->e_blkno);
+                        break;
+                }
+        }
+        if (!e_blkno) {
+                ocfs2_error(inode->i_sb, "Inode %lu has bad extent "
+                            "record (%u, %u, 0) in xattr", inode->i_ino,
+                            le32_to_cpu(rec->e_cpos),
+                            ocfs2_rec_clusters(el, rec));
+                ret = -EROFS;
+                goto out;
+        }
+        *p_blkno = le64_to_cpu(rec->e_blkno);
+        *num_clusters = le16_to_cpu(rec->e_leaf_clusters);
+        if (e_cpos)
+                *e_cpos = le32_to_cpu(rec->e_cpos);
+out:
+        brelse(eb_bh);
+        return ret;
+}
+typedef int (xattr_bucket_func)(struct inode *inode,
+                                struct ocfs2_xattr_bucket *bucket,
+                                void *para);
+static int ocfs2_find_xe_in_bucket(struct inode *inode,
+                                   struct buffer_head *header_bh,
+                                   int name_index,
+                                   const char *name,
+                                   u32 name_hash,
+                                   u16 *xe_index,
+                                   int *found)
+{
+        int i, ret = 0, cmp = 1, block_off, new_offset;
+        struct ocfs2_xattr_header *xh =
+                        (struct ocfs2_xattr_header *)header_bh->b_data;
+        size_t name_len = strlen(name);
+        struct ocfs2_xattr_entry *xe = NULL;
+        struct buffer_head *name_bh = NULL;
+        char *xe_name;
+        /*
+         * We don't use binary search in the bucket because there
+         * may be multiple entries with the same name hash.
+         */
+        for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
+                xe = &xh->xh_entries[i];
+                if (name_hash > le32_to_cpu(xe->xe_name_hash))
+                        continue;
+                else if (name_hash < le32_to_cpu(xe->xe_name_hash))
+                        break;
+                cmp = name_index - ocfs2_xattr_get_type(xe);
+                if (!cmp)
+                        cmp = name_len - xe->xe_name_len;
+                if (cmp)
+                        continue;
+                ret = ocfs2_xattr_bucket_get_name_value(inode,
+                                                        xh,
+                                                        i,
+                                                        &block_off,
+                                                        &new_offset);
+                if (ret) {
+                        mlog_errno(ret);
+                        break;
+                }
+                ret = ocfs2_read_block(inode, header_bh->b_blocknr + block_off,
+                                       &name_bh);
+                if (ret) {
+                        mlog_errno(ret);
+                        break;
+                }
+                xe_name = name_bh->b_data + new_offset;
+                cmp = memcmp(name, xe_name, name_len);
+                brelse(name_bh);
+                name_bh = NULL;
+                if (cmp == 0) {
+                        *xe_index = i;
+                        *found = 1;
+                        ret = 0;
+                        break;
+                }
+        }
+        return ret;
+}
+/*
+ * Find the specified xattr entry in a series of buckets.
+ * This series start from p_blkno and last for num_clusters.
+ * The ocfs2_xattr_header.xh_num_buckets of the first bucket contains
+ * the num of the valid buckets.
+ *
+ * Return the buffer_head this xattr should reside in. And if the xattr's
+ * hash is in the gap of 2 buckets, return the lower bucket.
+ */
+static int ocfs2_xattr_bucket_find(struct inode *inode,
+                                   int name_index,
+                                   const char *name,
+                                   u32 name_hash,
+                                   u64 p_blkno,
+                                   u32 first_hash,
+                                   u32 num_clusters,
+                                   struct ocfs2_xattr_search *xs)
+{
+        int ret, found = 0;
+        struct buffer_head *bh = NULL;
+        struct buffer_head *lower_bh = NULL;
+        struct ocfs2_xattr_header *xh = NULL;
+        struct ocfs2_xattr_entry *xe = NULL;
+        u16 index = 0;
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        int low_bucket = 0, bucket, high_bucket;
+        u32 last_hash;
+        u64 blkno;
+        ret = ocfs2_read_block(inode, p_blkno, &bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        xh = (struct ocfs2_xattr_header *)bh->b_data;
+        high_bucket = le16_to_cpu(xh->xh_num_buckets) - 1;
+        while (low_bucket <= high_bucket) {
+                brelse(bh);
+                bh = NULL;
+                bucket = (low_bucket + high_bucket) / 2;
+                blkno = p_blkno + bucket * blk_per_bucket;
+                ret = ocfs2_read_block(inode, blkno, &bh);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                xh = (struct ocfs2_xattr_header *)bh->b_data;
+                xe = &xh->xh_entries[0];
+                if (name_hash < le32_to_cpu(xe->xe_name_hash)) {
+                        high_bucket = bucket - 1;
+                        continue;
+                }
+                /*
+                 * Check whether the hash of the last entry in our
+                 * bucket is larger than the search one. for an empty
+                 * bucket, the last one is also the first one.
+                 */
+                if (xh->xh_count)
+                        xe = &xh->xh_entries[le16_to_cpu(xh->xh_count) - 1];
+                last_hash = le32_to_cpu(xe->xe_name_hash);
+                /* record lower_bh which may be the insert place. */
+                brelse(lower_bh);
+                lower_bh = bh;
+                bh = NULL;
+                if (name_hash > le32_to_cpu(xe->xe_name_hash)) {
+                        low_bucket = bucket + 1;
+                        continue;
+                }
+                /* the searched xattr should reside in this bucket if exists. */
+                ret = ocfs2_find_xe_in_bucket(inode, lower_bh,
+                                              name_index, name, name_hash,
+                                              &index, &found);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                break;
+        }
+        /*
+         * Record the bucket we have found.
+         * When the xattr's hash value is in the gap of 2 buckets, we will
+         * always set it to the previous bucket.
+         */
+        if (!lower_bh) {
+                /*
+                 * We can't find any bucket whose first name_hash is less
+                 * than the find name_hash.
+                 */
+                BUG_ON(bh->b_blocknr != p_blkno);
+                lower_bh = bh;
+                bh = NULL;
+        }
+        xs->bucket.bhs[0] = lower_bh;
+        xs->bucket.xh = (struct ocfs2_xattr_header *)
+                                        xs->bucket.bhs[0]->b_data;
+        lower_bh = NULL;
+        xs->header = xs->bucket.xh;
+        xs->base = xs->bucket.bhs[0]->b_data;
+        xs->end = xs->base + inode->i_sb->s_blocksize;
+        if (found) {
+                /*
+                 * If we have found the xattr enty, read all the blocks in
+                 * this bucket.
+                 */
+                ret = ocfs2_read_blocks(inode, xs->bucket.bhs[0]->b_blocknr + 1,
+                                        blk_per_bucket - 1, &xs->bucket.bhs[1],
+                                        OCFS2_BH_CACHED);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                xs->here = &xs->header->xh_entries[index];
+                mlog(0, "find xattr %s in bucket %llu, entry = %u\n", name,
+                     (unsigned long long)xs->bucket.bhs[0]->b_blocknr, index);
+        } else
+                ret = -ENODATA;
+out:
+        brelse(bh);
+        brelse(lower_bh);
+        return ret;
+}
+static int ocfs2_xattr_index_block_find(struct inode *inode,
+                                        struct buffer_head *root_bh,
+                                        int name_index,
+                                        const char *name,
+                                        struct ocfs2_xattr_search *xs)
+{
+        int ret;
+        struct ocfs2_xattr_block *xb =
+                        (struct ocfs2_xattr_block *)root_bh->b_data;
+        struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
+        struct ocfs2_extent_list *el = &xb_root->xt_list;
+        u64 p_blkno = 0;
+        u32 first_hash, num_clusters = 0;
+        u32 name_hash = ocfs2_xattr_name_hash(inode, name, strlen(name));
+        if (le16_to_cpu(el->l_next_free_rec) == 0)
+                return -ENODATA;
+        mlog(0, "find xattr %s, hash = %u, index = %d in xattr tree\n",
+             name, name_hash, name_index);
+        ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &first_hash,
+                                  &num_clusters, el);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        BUG_ON(p_blkno == 0 || num_clusters == 0 || first_hash > name_hash);
+        mlog(0, "find xattr extent rec %u clusters from %llu, the first hash "
+             "in the rec is %u\n", num_clusters, p_blkno, first_hash);
+        ret = ocfs2_xattr_bucket_find(inode, name_index, name, name_hash,
+                                      p_blkno, first_hash, num_clusters, xs);
+out:
+        return ret;
+}
+static int ocfs2_iterate_xattr_buckets(struct inode *inode,
+                                       u64 blkno,
+                                       u32 clusters,
+                                       xattr_bucket_func *func,
+                                       void *para)
+{
+        int i, j, ret = 0;
+        int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb));
+        u32 num_buckets = clusters * bpc;
+        struct ocfs2_xattr_bucket bucket;
+        memset(&bucket, 0, sizeof(bucket));
+        mlog(0, "iterating xattr buckets in %u clusters starting from %llu\n",
+             clusters, blkno);
+        for (i = 0; i < num_buckets; i++, blkno += blk_per_bucket) {
+                ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket,
+                                        bucket.bhs, OCFS2_BH_CACHED);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                bucket.xh = (struct ocfs2_xattr_header *)bucket.bhs[0]->b_data;
+                /*
+                 * The real bucket num in this series of blocks is stored
+                 * in the 1st bucket.
+                 */
+                if (i == 0)
+                        num_buckets = le16_to_cpu(bucket.xh->xh_num_buckets);
+                mlog(0, "iterating xattr bucket %llu, first hash %u\n", blkno,
+                     le32_to_cpu(bucket.xh->xh_entries[0].xe_name_hash));
+                if (func) {
+                        ret = func(inode, &bucket, para);
+                        if (ret) {
+                                mlog_errno(ret);
+                                break;
+                        }
+                }
+                for (j = 0; j < blk_per_bucket; j++)
+                        brelse(bucket.bhs[j]);
+                memset(&bucket, 0, sizeof(bucket));
+        }
+out:
+        for (j = 0; j < blk_per_bucket; j++)
+                brelse(bucket.bhs[j]);
+        return ret;
+}
+struct ocfs2_xattr_tree_list {
+        char *buffer;
+        size_t buffer_size;
+        size_t result;
+};
+static int ocfs2_xattr_bucket_get_name_value(struct inode *inode,
+                                             struct ocfs2_xattr_header *xh,
+                                             int index,
+                                             int *block_off,
+                                             int *new_offset)
+{
+        u16 name_offset;
+        if (index < 0 || index >= le16_to_cpu(xh->xh_count))
+                return -EINVAL;
+        name_offset = le16_to_cpu(xh->xh_entries[index].xe_name_offset);
+        *block_off = name_offset >> inode->i_sb->s_blocksize_bits;
+        *new_offset = name_offset % inode->i_sb->s_blocksize;
+        return 0;
+}
+static int ocfs2_list_xattr_bucket(struct inode *inode,
+                                   struct ocfs2_xattr_bucket *bucket,
+                                   void *para)
+{
+        int ret = 0, type;
+        struct ocfs2_xattr_tree_list *xl = (struct ocfs2_xattr_tree_list *)para;
+        int i, block_off, new_offset;
+        const char *prefix, *name;
+        for (i = 0 ; i < le16_to_cpu(bucket->xh->xh_count); i++) {
+                struct ocfs2_xattr_entry *entry = &bucket->xh->xh_entries[i];
+                type = ocfs2_xattr_get_type(entry);
+                prefix = ocfs2_xattr_prefix(type);
+                if (prefix) {
+                        ret = ocfs2_xattr_bucket_get_name_value(inode,
+                                                                bucket->xh,
+                                                                i,
+                                                                &block_off,
+                                                                &new_offset);
+                        if (ret)
+                                break;
+                        name = (const char *)bucket->bhs[block_off]->b_data +
+                                new_offset;
+                        ret = ocfs2_xattr_list_entry(xl->buffer,
+                                                     xl->buffer_size,
+                                                     &xl->result,
+                                                     prefix, name,
+                                                     entry->xe_name_len);
+                        if (ret)
+                                break;
+                }
+        }
+        return ret;
+}
+static int ocfs2_xattr_tree_list_index_block(struct inode *inode,
+                                             struct ocfs2_xattr_tree_root *xt,
+                                             char *buffer,
+                                             size_t buffer_size)
+{
+        struct ocfs2_extent_list *el = &xt->xt_list;
+        int ret = 0;
+        u32 name_hash = UINT_MAX, e_cpos = 0, num_clusters = 0;
+        u64 p_blkno = 0;
+        struct ocfs2_xattr_tree_list xl = {
+                .buffer = buffer,
+                .buffer_size = buffer_size,
+                .result = 0,
+        };
+        if (le16_to_cpu(el->l_next_free_rec) == 0)
+                return 0;
+        while (name_hash > 0) {
+                ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
+                                          &e_cpos, &num_clusters, el);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
+                                                  ocfs2_list_xattr_bucket,
+                                                  &xl);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                if (e_cpos == 0)
+                        break;
+                name_hash = e_cpos - 1;
+        }
+        ret = xl.result;
+out:
+        return ret;
+}
+static int cmp_xe(const void *a, const void *b)
+{
+        const struct ocfs2_xattr_entry *l = a, *r = b;
+        u32 l_hash = le32_to_cpu(l->xe_name_hash);
+        u32 r_hash = le32_to_cpu(r->xe_name_hash);
+        if (l_hash > r_hash)
+                return 1;
+        if (l_hash < r_hash)
+                return -1;
+        return 0;
+}
+static void swap_xe(void *a, void *b, int size)
+{
+        struct ocfs2_xattr_entry *l = a, *r = b, tmp;
+        tmp = *l;
+        memcpy(l, r, sizeof(struct ocfs2_xattr_entry));
+        memcpy(r, &tmp, sizeof(struct ocfs2_xattr_entry));
+}
+/*
+ * When the ocfs2_xattr_block is filled up, new bucket will be created
+ * and all the xattr entries will be moved to the new bucket.
+ * Note: we need to sort the entries since they are not saved in order
+ * in the ocfs2_xattr_block.
+ */
+static void ocfs2_cp_xattr_block_to_bucket(struct inode *inode,
+                                           struct buffer_head *xb_bh,
+                                           struct buffer_head *xh_bh,
+                                           struct buffer_head *data_bh)
+{
+        int i, blocksize = inode->i_sb->s_blocksize;
+        u16 offset, size, off_change;
+        struct ocfs2_xattr_entry *xe;
+        struct ocfs2_xattr_block *xb =
+                                (struct ocfs2_xattr_block *)xb_bh->b_data;
+        struct ocfs2_xattr_header *xb_xh = &xb->xb_attrs.xb_header;
+        struct ocfs2_xattr_header *xh =
+                                (struct ocfs2_xattr_header *)xh_bh->b_data;
+        u16 count = le16_to_cpu(xb_xh->xh_count);
+        char *target = xh_bh->b_data, *src = xb_bh->b_data;
+        mlog(0, "cp xattr from block %llu to bucket %llu\n",
+             (unsigned long long)xb_bh->b_blocknr,
+             (unsigned long long)xh_bh->b_blocknr);
+        memset(xh_bh->b_data, 0, blocksize);
+        if (data_bh)
+                memset(data_bh->b_data, 0, blocksize);
+        /*
+         * Since the xe_name_offset is based on ocfs2_xattr_header,
+         * there is a offset change corresponding to the change of
+         * ocfs2_xattr_header's position.
+         */
+        off_change = offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
+        xe = &xb_xh->xh_entries[count - 1];
+        offset = le16_to_cpu(xe->xe_name_offset) + off_change;
+        size = blocksize - offset;
+        /* copy all the names and values. */
+        if (data_bh)
+                target = data_bh->b_data;
+        memcpy(target + offset, src + offset, size);
+        /* Init new header now. */
+        xh->xh_count = xb_xh->xh_count;
+        xh->xh_num_buckets = cpu_to_le16(1);
+        xh->xh_name_value_len = cpu_to_le16(size);
+        xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE - size);
+        /* copy all the entries. */
+        target = xh_bh->b_data;
+        offset = offsetof(struct ocfs2_xattr_header, xh_entries);
+        size = count * sizeof(struct ocfs2_xattr_entry);
+        memcpy(target + offset, (char *)xb_xh + offset, size);
+        /* Change the xe offset for all the xe because of the move. */
+        off_change = OCFS2_XATTR_BUCKET_SIZE - blocksize +
+                 offsetof(struct ocfs2_xattr_block, xb_attrs.xb_header);
+        for (i = 0; i < count; i++)
+                le16_add_cpu(&xh->xh_entries[i].xe_name_offset, off_change);
+        mlog(0, "copy entry: start = %u, size = %u, offset_change = %u\n",
+             offset, size, off_change);
+        sort(target + offset, count, sizeof(struct ocfs2_xattr_entry),
+             cmp_xe, swap_xe);
+}
+/*
+ * After we move xattr from block to index btree, we have to
+ * update ocfs2_xattr_search to the new xe and base.
+ *
+ * When the entry is in xattr block, xattr_bh indicates the storage place.
+ * While if the entry is in index b-tree, "bucket" indicates the
+ * real place of the xattr.
+ */
+static int ocfs2_xattr_update_xattr_search(struct inode *inode,
+                                           struct ocfs2_xattr_search *xs,
+                                           struct buffer_head *old_bh,
+                                           struct buffer_head *new_bh)
+{
+        int ret = 0;
+        char *buf = old_bh->b_data;
+        struct ocfs2_xattr_block *old_xb = (struct ocfs2_xattr_block *)buf;
+        struct ocfs2_xattr_header *old_xh = &old_xb->xb_attrs.xb_header;
+        int i, blocksize = inode->i_sb->s_blocksize;
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        xs->bucket.bhs[0] = new_bh;
+        get_bh(new_bh);
+        xs->bucket.xh = (struct ocfs2_xattr_header *)xs->bucket.bhs[0]->b_data;
+        xs->header = xs->bucket.xh;
+        xs->base = new_bh->b_data;
+        xs->end = xs->base + inode->i_sb->s_blocksize;
+        if (!xs->not_found) {
+                if (OCFS2_XATTR_BUCKET_SIZE != blocksize) {
+                        ret = ocfs2_read_blocks(inode,
+                                        xs->bucket.bhs[0]->b_blocknr + 1,
+                                        blk_per_bucket - 1, &xs->bucket.bhs[1],
+                                        OCFS2_BH_CACHED);
+                        if (ret) {
+                                mlog_errno(ret);
+                                return ret;
+                        }
+                        i = xs->here - old_xh->xh_entries;
+                        xs->here = &xs->header->xh_entries[i];
+                }
+        }
+        return ret;
+}
+static int ocfs2_xattr_create_index_block(struct inode *inode,
+                                          struct ocfs2_xattr_search *xs)
+{
+        int ret, credits = OCFS2_SUBALLOC_ALLOC;
+        u32 bit_off, len;
+        u64 blkno;
+        handle_t *handle;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_alloc_context *data_ac;
+        struct buffer_head *xh_bh = NULL, *data_bh = NULL;
+        struct buffer_head *xb_bh = xs->xattr_bh;
+        struct ocfs2_xattr_block *xb =
+                        (struct ocfs2_xattr_block *)xb_bh->b_data;
+        struct ocfs2_xattr_tree_root *xr;
+        u16 xb_flags = le16_to_cpu(xb->xb_flags);
+        u16 bpb = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        mlog(0, "create xattr index block for %llu\n",
+             (unsigned long long)xb_bh->b_blocknr);
+        BUG_ON(xb_flags & OCFS2_XATTR_INDEXED);
+        ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        /*
+         * XXX:
+         * We can use this lock for now, and maybe move to a dedicated mutex
+         * if performance becomes a problem later.
+         */
+        down_write(&oi->ip_alloc_sem);
+        /*
+         * 3 more credits, one for xattr block update, one for the 1st block
+         * of the new xattr bucket and one for the value/data.
+         */
+        credits += 3;
+        handle = ocfs2_start_trans(osb, credits);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out_sem;
+        }
+        ret = ocfs2_journal_access(handle, inode, xb_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off, &len);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        /*
+         * The bucket may spread in many blocks, and
+         * we will only touch the 1st block and the last block
+         * in the whole bucket(one for entry and one for data).
+         */
+        blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
+        mlog(0, "allocate 1 cluster from %llu to xattr block\n", blkno);
+        xh_bh = sb_getblk(inode->i_sb, blkno);
+        if (!xh_bh) {
+                ret = -EIO;
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        ocfs2_set_new_buffer_uptodate(inode, xh_bh);
+        ret = ocfs2_journal_access(handle, inode, xh_bh,
+                                   OCFS2_JOURNAL_ACCESS_CREATE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        if (bpb > 1) {
+                data_bh = sb_getblk(inode->i_sb, blkno + bpb - 1);
+                if (!data_bh) {
+                        ret = -EIO;
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+                ocfs2_set_new_buffer_uptodate(inode, data_bh);
+                ret = ocfs2_journal_access(handle, inode, data_bh,
+                                           OCFS2_JOURNAL_ACCESS_CREATE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_commit;
+                }
+        }
+        ocfs2_cp_xattr_block_to_bucket(inode, xb_bh, xh_bh, data_bh);
+        ocfs2_journal_dirty(handle, xh_bh);
+        if (data_bh)
+                ocfs2_journal_dirty(handle, data_bh);
+        ocfs2_xattr_update_xattr_search(inode, xs, xb_bh, xh_bh);
+        /* Change from ocfs2_xattr_header to ocfs2_xattr_tree_root */
+        memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize -
+               offsetof(struct ocfs2_xattr_block, xb_attrs));
+        xr = &xb->xb_attrs.xb_root;
+        xr->xt_clusters = cpu_to_le32(1);
+        xr->xt_last_eb_blk = 0;
+        xr->xt_list.l_tree_depth = 0;
+        xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb));
+        xr->xt_list.l_next_free_rec = cpu_to_le16(1);
+        xr->xt_list.l_recs[0].e_cpos = 0;
+        xr->xt_list.l_recs[0].e_blkno = cpu_to_le64(blkno);
+        xr->xt_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1);
+        xb->xb_flags = cpu_to_le16(xb_flags | OCFS2_XATTR_INDEXED);
+        ret = ocfs2_journal_dirty(handle, xb_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out_sem:
+        up_write(&oi->ip_alloc_sem);
+out:
+        if (data_ac)
+                ocfs2_free_alloc_context(data_ac);
+        brelse(xh_bh);
+        brelse(data_bh);
+        return ret;
+}
+static int cmp_xe_offset(const void *a, const void *b)
+{
+        const struct ocfs2_xattr_entry *l = a, *r = b;
+        u32 l_name_offset = le16_to_cpu(l->xe_name_offset);
+        u32 r_name_offset = le16_to_cpu(r->xe_name_offset);
+        if (l_name_offset < r_name_offset)
+                return 1;
+        if (l_name_offset > r_name_offset)
+                return -1;
+        return 0;
+}
+/*
+ * defrag a xattr bucket if we find that the bucket has some
+ * holes beteen name/value pairs.
+ * We will move all the name/value pairs to the end of the bucket
+ * so that we can spare some space for insertion.
+ */
+static int ocfs2_defrag_xattr_bucket(struct inode *inode,
+                                     struct ocfs2_xattr_bucket *bucket)
+{
+        int ret, i;
+        size_t end, offset, len, value_len;
+        struct ocfs2_xattr_header *xh;
+        char *entries, *buf, *bucket_buf = NULL;
+        u64 blkno = bucket->bhs[0]->b_blocknr;
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        u16 xh_free_start;
+        size_t blocksize = inode->i_sb->s_blocksize;
+        handle_t *handle;
+        struct buffer_head **bhs;
+        struct ocfs2_xattr_entry *xe;
+        bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket,
+                        GFP_NOFS);
+        if (!bhs)
+                return -ENOMEM;
+        ret = ocfs2_read_blocks(inode, blkno, blk_per_bucket, bhs,
+                                OCFS2_BH_CACHED);
+        if (ret)
+                goto out;
+        /*
+         * In order to make the operation more efficient and generic,
+         * we copy all the blocks into a contiguous memory and do the
+         * defragment there, so if anything is error, we will not touch
+         * the real block.
+         */
+        bucket_buf = kmalloc(OCFS2_XATTR_BUCKET_SIZE, GFP_NOFS);
+        if (!bucket_buf) {
+                ret = -EIO;
+                goto out;
+        }
+        buf = bucket_buf;
+        for (i = 0; i < blk_per_bucket; i++, buf += blocksize)
+                memcpy(buf, bhs[i]->b_data, blocksize);
+        handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), blk_per_bucket);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                handle = NULL;
+                mlog_errno(ret);
+                goto out;
+        }
+        for (i = 0; i < blk_per_bucket; i++) {
+                ret = ocfs2_journal_access(handle, inode, bhs[i],
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto commit;
+                }
+        }
+        xh = (struct ocfs2_xattr_header *)bucket_buf;
+        entries = (char *)xh->xh_entries;
+        xh_free_start = le16_to_cpu(xh->xh_free_start);
+        mlog(0, "adjust xattr bucket in %llu, count = %u, "
+             "xh_free_start = %u, xh_name_value_len = %u.\n",
+             blkno, le16_to_cpu(xh->xh_count), xh_free_start,
+             le16_to_cpu(xh->xh_name_value_len));
+        /*
+         * sort all the entries by their offset.
+         * the largest will be the first, so that we can
+         * move them to the end one by one.
+         */
+        sort(entries, le16_to_cpu(xh->xh_count),
+             sizeof(struct ocfs2_xattr_entry),
+             cmp_xe_offset, swap_xe);
+        /* Move all name/values to the end of the bucket. */
+        xe = xh->xh_entries;
+        end = OCFS2_XATTR_BUCKET_SIZE;
+        for (i = 0; i < le16_to_cpu(xh->xh_count); i++, xe++) {
+                offset = le16_to_cpu(xe->xe_name_offset);
+                if (ocfs2_xattr_is_local(xe))
+                        value_len = OCFS2_XATTR_SIZE(
+                                        le64_to_cpu(xe->xe_value_size));
+                else
+                        value_len = OCFS2_XATTR_ROOT_SIZE;
+                len = OCFS2_XATTR_SIZE(xe->xe_name_len) + value_len;
+                /*
+                 * We must make sure that the name/value pair
+                 * exist in the same block. So adjust end to
+                 * the previous block end if needed.
+                 */
+                if (((end - len) / blocksize !=
+                        (end - 1) / blocksize))
+                        end = end - end % blocksize;
+                if (end > offset + len) {
+                        memmove(bucket_buf + end - len,
+                                bucket_buf + offset, len);
+                        xe->xe_name_offset = cpu_to_le16(end - len);
+                }
+                mlog_bug_on_msg(end < offset + len, "Defrag check failed for "
+                                "bucket %llu\n", (unsigned long long)blkno);
+                end -= len;
+        }
+        mlog_bug_on_msg(xh_free_start > end, "Defrag check failed for "
+                        "bucket %llu\n", (unsigned long long)blkno);
+        if (xh_free_start == end)
+                goto commit;
+        memset(bucket_buf + xh_free_start, 0, end - xh_free_start);
+        xh->xh_free_start = cpu_to_le16(end);
+        /* sort the entries by their name_hash. */
+        sort(entries, le16_to_cpu(xh->xh_count),
+             sizeof(struct ocfs2_xattr_entry),
+             cmp_xe, swap_xe);
+        buf = bucket_buf;
+        for (i = 0; i < blk_per_bucket; i++, buf += blocksize) {
+                memcpy(bhs[i]->b_data, buf, blocksize);
+                ocfs2_journal_dirty(handle, bhs[i]);
+        }
+commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+out:
+        if (bhs) {
+                for (i = 0; i < blk_per_bucket; i++)
+                        brelse(bhs[i]);
+        }
+        kfree(bhs);
+        kfree(bucket_buf);
+        return ret;
+}
+/*
+ * Move half nums of the xattr bucket in the previous cluster to this new
+ * cluster. We only touch the last cluster of the previous extend record.
+ *
+ * first_bh is the first buffer_head of a series of bucket in the same
+ * extent rec and header_bh is the header of one bucket in this cluster.
+ * They will be updated if we move the data header_bh contains to the new
+ * cluster. first_hash will be set as the 1st xe's name_hash of the new cluster.
+ */
+static int ocfs2_mv_xattr_bucket_cross_cluster(struct inode *inode,
+                                               handle_t *handle,
+                                               struct buffer_head **first_bh,
+                                               struct buffer_head **header_bh,
+                                               u64 new_blkno,
+                                               u64 prev_blkno,
+                                               u32 num_clusters,
+                                               u32 *first_hash)
+{
+        int i, ret, credits;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+        int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
+        int blocksize = inode->i_sb->s_blocksize;
+        struct buffer_head *old_bh, *new_bh, *prev_bh, *new_first_bh = NULL;
+        struct ocfs2_xattr_header *new_xh;
+        struct ocfs2_xattr_header *xh =
+                        (struct ocfs2_xattr_header *)((*first_bh)->b_data);
+        BUG_ON(le16_to_cpu(xh->xh_num_buckets) < num_buckets);
+        BUG_ON(OCFS2_XATTR_BUCKET_SIZE == osb->s_clustersize);
+        prev_bh = *first_bh;
+        get_bh(prev_bh);
+        xh = (struct ocfs2_xattr_header *)prev_bh->b_data;
+        prev_blkno += (num_clusters - 1) * bpc + bpc / 2;
+        mlog(0, "move half of xattrs in cluster %llu to %llu\n",
+             prev_blkno, new_blkno);
+        /*
+         * We need to update the 1st half of the new cluster and
+         * 1 more for the update of the 1st bucket of the previous
+         * extent record.
+         */
+        credits = bpc / 2 + 1;
+        ret = ocfs2_extend_trans(handle, credits);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, prev_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        for (i = 0; i < bpc / 2; i++, prev_blkno++, new_blkno++) {
+                old_bh = new_bh = NULL;
+                new_bh = sb_getblk(inode->i_sb, new_blkno);
+                if (!new_bh) {
+                        ret = -EIO;
+                        mlog_errno(ret);
+                        goto out;
+                }
+                ocfs2_set_new_buffer_uptodate(inode, new_bh);
+                ret = ocfs2_journal_access(handle, inode, new_bh,
+                                           OCFS2_JOURNAL_ACCESS_CREATE);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        brelse(new_bh);
+                        goto out;
+                }
+                ret = ocfs2_read_block(inode, prev_blkno, &old_bh);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        brelse(new_bh);
+                        goto out;
+                }
+                memcpy(new_bh->b_data, old_bh->b_data, blocksize);
+                if (i == 0) {
+                        new_xh = (struct ocfs2_xattr_header *)new_bh->b_data;
+                        new_xh->xh_num_buckets = cpu_to_le16(num_buckets / 2);
+                        if (first_hash)
+                                *first_hash = le32_to_cpu(
+                                        new_xh->xh_entries[0].xe_name_hash);
+                        new_first_bh = new_bh;
+                        get_bh(new_first_bh);
+                }
+                ocfs2_journal_dirty(handle, new_bh);
+                if (*header_bh == old_bh) {
+                        brelse(*header_bh);
+                        *header_bh = new_bh;
+                        get_bh(*header_bh);
+                        brelse(*first_bh);
+                        *first_bh = new_first_bh;
+                        get_bh(*first_bh);
+                }
+                brelse(new_bh);
+                brelse(old_bh);
+        }
+        le16_add_cpu(&xh->xh_num_buckets, -(num_buckets / 2));
+        ocfs2_journal_dirty(handle, prev_bh);
+out:
+        brelse(prev_bh);
+        brelse(new_first_bh);
+        return ret;
+}
+static int ocfs2_read_xattr_bucket(struct inode *inode,
+                                   u64 blkno,
+                                   struct buffer_head **bhs,
+                                   int new)
+{
+        int ret = 0;
+        u16 i, blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        if (!new)
+                return ocfs2_read_blocks(inode, blkno,
+                                         blk_per_bucket, bhs,
+                                         OCFS2_BH_CACHED);
+        for (i = 0; i < blk_per_bucket; i++) {
+                bhs[i] = sb_getblk(inode->i_sb, blkno + i);
+                if (bhs[i] == NULL) {
+                        ret = -EIO;
+                        mlog_errno(ret);
+                        break;
+                }
+                ocfs2_set_new_buffer_uptodate(inode, bhs[i]);
+        }
+        return ret;
+}
+/*
+ * Move half num of the xattrs in old bucket(blk) to new bucket(new_blk).
+ * first_hash will record the 1st hash of the new bucket.
+ */
+static int ocfs2_half_xattr_bucket(struct inode *inode,
+                                   handle_t *handle,
+                                   u64 blk,
+                                   u64 new_blk,
+                                   u32 *first_hash,
+                                   int new_bucket_head)
+{
+        int ret, i;
+        u16 count, start, len, name_value_len, xe_len, name_offset;
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        struct buffer_head **s_bhs, **t_bhs = NULL;
+        struct ocfs2_xattr_header *xh;
+        struct ocfs2_xattr_entry *xe;
+        int blocksize = inode->i_sb->s_blocksize;
+        mlog(0, "move half of xattrs from bucket %llu to %llu\n",
+             blk, new_blk);
+        s_bhs = kcalloc(blk_per_bucket, sizeof(struct buffer_head *), GFP_NOFS);
+        if (!s_bhs)
+                return -ENOMEM;
+        ret = ocfs2_read_xattr_bucket(inode, blk, s_bhs, 0);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, s_bhs[0],
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        t_bhs = kcalloc(blk_per_bucket, sizeof(struct buffer_head *), GFP_NOFS);
+        if (!t_bhs) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ret = ocfs2_read_xattr_bucket(inode, new_blk, t_bhs, new_bucket_head);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        for (i = 0; i < blk_per_bucket; i++) {
+                ret = ocfs2_journal_access(handle, inode, t_bhs[i],
+                                           OCFS2_JOURNAL_ACCESS_CREATE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        /* copy the whole bucket to the new first. */
+        for (i = 0; i < blk_per_bucket; i++)
+                memcpy(t_bhs[i]->b_data, s_bhs[i]->b_data, blocksize);
+        /* update the new bucket. */
+        xh = (struct ocfs2_xattr_header *)t_bhs[0]->b_data;
+        count = le16_to_cpu(xh->xh_count);
+        start = count / 2;
+        /*
+         * Calculate the total name/value len and xh_free_start for
+         * the old bucket first.
+         */
+        name_offset = OCFS2_XATTR_BUCKET_SIZE;
+        name_value_len = 0;
+        for (i = 0; i < start; i++) {
+                xe = &xh->xh_entries[i];
+                xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
+                if (ocfs2_xattr_is_local(xe))
+                        xe_len +=
+                           OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
+                else
+                        xe_len += OCFS2_XATTR_ROOT_SIZE;
+                name_value_len += xe_len;
+                if (le16_to_cpu(xe->xe_name_offset) < name_offset)
+                        name_offset = le16_to_cpu(xe->xe_name_offset);
+        }
+        /*
+         * Now begin the modification to the new bucket.
+         *
+         * In the new bucket, We just move the xattr entry to the beginning
+         * and don't touch the name/value. So there will be some holes in the
+         * bucket, and they will be removed when ocfs2_defrag_xattr_bucket is
+         * called.
+         */
+        xe = &xh->xh_entries[start];
+        len = sizeof(struct ocfs2_xattr_entry) * (count - start);
+        mlog(0, "mv xattr entry len %d from %d to %d\n", len,
+             (int)((char *)xe - (char *)xh),
+             (int)((char *)xh->xh_entries - (char *)xh));
+        memmove((char *)xh->xh_entries, (char *)xe, len);
+        xe = &xh->xh_entries[count - start];
+        len = sizeof(struct ocfs2_xattr_entry) * start;
+        memset((char *)xe, 0, len);
+        le16_add_cpu(&xh->xh_count, -start);
+        le16_add_cpu(&xh->xh_name_value_len, -name_value_len);
+        /* Calculate xh_free_start for the new bucket. */
+        xh->xh_free_start = cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
+        for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
+                xe = &xh->xh_entries[i];
+                xe_len = OCFS2_XATTR_SIZE(xe->xe_name_len);
+                if (ocfs2_xattr_is_local(xe))
+                        xe_len +=
+                           OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
+                else
+                        xe_len += OCFS2_XATTR_ROOT_SIZE;
+                if (le16_to_cpu(xe->xe_name_offset) <
+                    le16_to_cpu(xh->xh_free_start))
+                        xh->xh_free_start = xe->xe_name_offset;
+        }
+        /* set xh->xh_num_buckets for the new xh. */
+        if (new_bucket_head)
+                xh->xh_num_buckets = cpu_to_le16(1);
+        else
+                xh->xh_num_buckets = 0;
+        for (i = 0; i < blk_per_bucket; i++) {
+                ocfs2_journal_dirty(handle, t_bhs[i]);
+                if (ret)
+                        mlog_errno(ret);
+        }
+        /* store the first_hash of the new bucket. */
+        if (first_hash)
+                *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
+        /*
+         * Now only update the 1st block of the old bucket.
+         * Please note that the entry has been sorted already above.
+         */
+        xh = (struct ocfs2_xattr_header *)s_bhs[0]->b_data;
+        memset(&xh->xh_entries[start], 0,
+               sizeof(struct ocfs2_xattr_entry) * (count - start));
+        xh->xh_count = cpu_to_le16(start);
+        xh->xh_free_start = cpu_to_le16(name_offset);
+        xh->xh_name_value_len = cpu_to_le16(name_value_len);
+        ocfs2_journal_dirty(handle, s_bhs[0]);
+        if (ret)
+                mlog_errno(ret);
+out:
+        if (s_bhs) {
+                for (i = 0; i < blk_per_bucket; i++)
+                        brelse(s_bhs[i]);
+        }
+        kfree(s_bhs);
+        if (t_bhs) {
+                for (i = 0; i < blk_per_bucket; i++)
+                        brelse(t_bhs[i]);
+        }
+        kfree(t_bhs);
+        return ret;
+}
+/*
+ * Copy xattr from one bucket to another bucket.
+ *
+ * The caller must make sure that the journal transaction
+ * has enough space for journaling.
+ */
+static int ocfs2_cp_xattr_bucket(struct inode *inode,
+                                 handle_t *handle,
+                                 u64 s_blkno,
+                                 u64 t_blkno,
+                                 int t_is_new)
+{
+        int ret, i;
+        int blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        int blocksize = inode->i_sb->s_blocksize;
+        struct buffer_head **s_bhs, **t_bhs = NULL;
+        BUG_ON(s_blkno == t_blkno);
+        mlog(0, "cp bucket %llu to %llu, target is %d\n",
+             s_blkno, t_blkno, t_is_new);
+        s_bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket,
+                        GFP_NOFS);
+        if (!s_bhs)
+                return -ENOMEM;
+        ret = ocfs2_read_xattr_bucket(inode, s_blkno, s_bhs, 0);
+        if (ret)
+                goto out;
+        t_bhs = kzalloc(sizeof(struct buffer_head *) * blk_per_bucket,
+                        GFP_NOFS);
+        if (!t_bhs) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ret = ocfs2_read_xattr_bucket(inode, t_blkno, t_bhs, t_is_new);
+        if (ret)
+                goto out;
+        for (i = 0; i < blk_per_bucket; i++) {
+                ret = ocfs2_journal_access(handle, inode, t_bhs[i],
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret)
+                        goto out;
+        }
+        for (i = 0; i < blk_per_bucket; i++) {
+                memcpy(t_bhs[i]->b_data, s_bhs[i]->b_data, blocksize);
+                ocfs2_journal_dirty(handle, t_bhs[i]);
+        }
+out:
+        if (s_bhs) {
+                for (i = 0; i < blk_per_bucket; i++)
+                        brelse(s_bhs[i]);
+        }
+        kfree(s_bhs);
+        if (t_bhs) {
+                for (i = 0; i < blk_per_bucket; i++)
+                        brelse(t_bhs[i]);
+        }
+        kfree(t_bhs);
+        return ret;
+}
+/*
+ * Copy one xattr cluster from src_blk to to_blk.
+ * The to_blk will become the first bucket header of the cluster, so its
+ * xh_num_buckets will be initialized as the bucket num in the cluster.
+ */
+static int ocfs2_cp_xattr_cluster(struct inode *inode,
+                                  handle_t *handle,
+                                  struct buffer_head *first_bh,
+                                  u64 src_blk,
+                                  u64 to_blk,
+                                  u32 *first_hash)
+{
+        int i, ret, credits;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+        int num_buckets = ocfs2_xattr_buckets_per_cluster(osb);
+        struct buffer_head *bh = NULL;
+        struct ocfs2_xattr_header *xh;
+        u64 to_blk_start = to_blk;
+        mlog(0, "cp xattrs from cluster %llu to %llu\n", src_blk, to_blk);
+        /*
+         * We need to update the new cluster and 1 more for the update of
+         * the 1st bucket of the previous extent rec.
+         */
+        credits = bpc + 1;
+        ret = ocfs2_extend_trans(handle, credits);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, first_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        for (i = 0; i < num_buckets; i++) {
+                ret = ocfs2_cp_xattr_bucket(inode, handle,
+                                            src_blk, to_blk, 1);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                src_blk += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+                to_blk += ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        }
+        /* update the old bucket header. */
+        xh = (struct ocfs2_xattr_header *)first_bh->b_data;
+        le16_add_cpu(&xh->xh_num_buckets, -num_buckets);
+        ocfs2_journal_dirty(handle, first_bh);
+        /* update the new bucket header. */
+        ret = ocfs2_read_block(inode, to_blk_start, &bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        xh = (struct ocfs2_xattr_header *)bh->b_data;
+        xh->xh_num_buckets = cpu_to_le16(num_buckets);
+        ocfs2_journal_dirty(handle, bh);
+        if (first_hash)
+                *first_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
+out:
+        brelse(bh);
+        return ret;
+}
+/*
+ * Move half of the xattrs in this cluster to the new cluster.
+ * This function should only be called when bucket size == cluster size.
+ * Otherwise ocfs2_mv_xattr_bucket_cross_cluster should be used instead.
+ */
+static int ocfs2_half_xattr_cluster(struct inode *inode,
+                                    handle_t *handle,
+                                    u64 prev_blk,
+                                    u64 new_blk,
+                                    u32 *first_hash)
+{
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        int ret, credits = 2 * blk_per_bucket;
+        BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize);
+        ret = ocfs2_extend_trans(handle, credits);
+        if (ret) {
+                mlog_errno(ret);
+                return ret;
+        }
+        /* Move half of the xattr in start_blk to the next bucket. */
+        return  ocfs2_half_xattr_bucket(inode, handle, prev_blk,
+                                        new_blk, first_hash, 1);
+}
+/*
+ * Move some xattrs from the old cluster to the new one since they are not
+ * contiguous in ocfs2 xattr tree.
+ *
+ * new_blk starts a new separate cluster, and we will move some xattrs from
+ * prev_blk to it. v_start will be set as the first name hash value in this
+ * new cluster so that it can be used as e_cpos during tree insertion and
+ * don't collide with our original b-tree operations. first_bh and header_bh
+ * will also be updated since they will be used in ocfs2_extend_xattr_bucket
+ * to extend the insert bucket.
+ *
+ * The problem is how much xattr should we move to the new one and when should
+ * we update first_bh and header_bh?
+ * 1. If cluster size > bucket size, that means the previous cluster has more
+ *    than 1 bucket, so just move half nums of bucket into the new cluster and
+ *    update the first_bh and header_bh if the insert bucket has been moved
+ *    to the new cluster.
+ * 2. If cluster_size == bucket_size:
+ *    a) If the previous extent rec has more than one cluster and the insert
+ *       place isn't in the last cluster, copy the entire last cluster to the
+ *       new one. This time, we don't need to upate the first_bh and header_bh
+ *       since they will not be moved into the new cluster.
+ *    b) Otherwise, move the bottom half of the xattrs in the last cluster into
+ *       the new one. And we set the extend flag to zero if the insert place is
+ *       moved into the new allocated cluster since no extend is needed.
+ */
+static int ocfs2_adjust_xattr_cross_cluster(struct inode *inode,
+                                            handle_t *handle,
+                                            struct buffer_head **first_bh,
+                                            struct buffer_head **header_bh,
+                                            u64 new_blk,
+                                            u64 prev_blk,
+                                            u32 prev_clusters,
+                                            u32 *v_start,
+                                            int *extend)
+{
+        int ret = 0;
+        int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+        mlog(0, "adjust xattrs from cluster %llu len %u to %llu\n",
+             prev_blk, prev_clusters, new_blk);
+        if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1)
+                ret = ocfs2_mv_xattr_bucket_cross_cluster(inode,
+                                                          handle,
+                                                          first_bh,
+                                                          header_bh,
+                                                          new_blk,
+                                                          prev_blk,
+                                                          prev_clusters,
+                                                          v_start);
+        else {
+                u64 last_blk = prev_blk + bpc * (prev_clusters - 1);
+                if (prev_clusters > 1 && (*header_bh)->b_blocknr != last_blk)
+                        ret = ocfs2_cp_xattr_cluster(inode, handle, *first_bh,
+                                                     last_blk, new_blk,
+                                                     v_start);
+                else {
+                        ret = ocfs2_half_xattr_cluster(inode, handle,
+                                                       last_blk, new_blk,
+                                                       v_start);
+                        if ((*header_bh)->b_blocknr == last_blk && extend)
+                                *extend = 0;
+                }
+        }
+        return ret;
+}
+/*
+ * Add a new cluster for xattr storage.
+ *
+ * If the new cluster is contiguous with the previous one, it will be
+ * appended to the same extent record, and num_clusters will be updated.
+ * If not, we will insert a new extent for it and move some xattrs in
+ * the last cluster into the new allocated one.
+ * We also need to limit the maximum size of a btree leaf, otherwise we'll
+ * lose the benefits of hashing because we'll have to search large leaves.
+ * So now the maximum size is OCFS2_MAX_XATTR_TREE_LEAF_SIZE(or clustersize,
+ * if it's bigger).
+ *
+ * first_bh is the first block of the previous extent rec and header_bh
+ * indicates the bucket we will insert the new xattrs. They will be updated
+ * when the header_bh is moved into the new cluster.
+ */
+static int ocfs2_add_new_xattr_cluster(struct inode *inode,
+                                       struct buffer_head *root_bh,
+                                       struct buffer_head **first_bh,
+                                       struct buffer_head **header_bh,
+                                       u32 *num_clusters,
+                                       u32 prev_cpos,
+                                       u64 prev_blkno,
+                                       int *extend)
+{
+        int ret, credits;
+        u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
+        u32 prev_clusters = *num_clusters;
+        u32 clusters_to_add = 1, bit_off, num_bits, v_start = 0;
+        u64 block;
+        handle_t *handle = NULL;
+        struct ocfs2_alloc_context *data_ac = NULL;
+        struct ocfs2_alloc_context *meta_ac = NULL;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_extent_tree et;
+        mlog(0, "Add new xattr cluster for %llu, previous xattr hash = %u, "
+             "previous xattr blkno = %llu\n",
+             (unsigned long long)OCFS2_I(inode)->ip_blkno,
+             prev_cpos, prev_blkno);
+        ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh);
+        ret = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
+                                    &data_ac, &meta_ac);
+        if (ret) {
+                mlog_errno(ret);
+                goto leave;
+        }
+        credits = ocfs2_calc_extend_credits(osb->sb, et.et_root_el,
+                                            clusters_to_add);
+        handle = ocfs2_start_trans(osb, credits);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                handle = NULL;
+                mlog_errno(ret);
+                goto leave;
+        }
+        ret = ocfs2_journal_access(handle, inode, root_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto leave;
+        }
+        ret = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
+                                     clusters_to_add, &bit_off, &num_bits);
+        if (ret < 0) {
+                if (ret != -ENOSPC)
+                        mlog_errno(ret);
+                goto leave;
+        }
+        BUG_ON(num_bits > clusters_to_add);
+        block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
+        mlog(0, "Allocating %u clusters at block %u for xattr in inode %llu\n",
+             num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
+        if (prev_blkno + prev_clusters * bpc == block &&
+            (prev_clusters + num_bits) << osb->s_clustersize_bits <=
+             OCFS2_MAX_XATTR_TREE_LEAF_SIZE) {
+                /*
+                 * If this cluster is contiguous with the old one and
+                 * adding this new cluster, we don't surpass the limit of
+                 * OCFS2_MAX_XATTR_TREE_LEAF_SIZE, cool. We will let it be
+                 * initialized and used like other buckets in the previous
+                 * cluster.
+                 * So add it as a contiguous one. The caller will handle
+                 * its init process.
+                 */
+                v_start = prev_cpos + prev_clusters;
+                *num_clusters = prev_clusters + num_bits;
+                mlog(0, "Add contiguous %u clusters to previous extent rec.\n",
+                     num_bits);
+        } else {
+                ret = ocfs2_adjust_xattr_cross_cluster(inode,
+                                                       handle,
+                                                       first_bh,
+                                                       header_bh,
+                                                       block,
+                                                       prev_blkno,
+                                                       prev_clusters,
+                                                       &v_start,
+                                                       extend);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto leave;
+                }
+        }
+        if (handle->h_buffer_credits < credits) {
+                /*
+                 * The journal has been restarted before, and don't
+                 * have enough space for the insertion, so extend it
+                 * here.
+                 */
+                ret = ocfs2_extend_trans(handle, credits);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto leave;
+                }
+        }
+        mlog(0, "Insert %u clusters at block %llu for xattr at %u\n",
+             num_bits, block, v_start);
+        ret = ocfs2_insert_extent(osb, handle, inode, &et, v_start, block,
+                                  num_bits, 0, meta_ac);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto leave;
+        }
+        ret = ocfs2_journal_dirty(handle, root_bh);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto leave;
+        }
+leave:
+        if (handle)
+                ocfs2_commit_trans(osb, handle);
+        if (data_ac)
+                ocfs2_free_alloc_context(data_ac);
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+        return ret;
+}
+/*
+ * Extend a new xattr bucket and move xattrs to the end one by one until
+ * We meet with start_bh. Only move half of the xattrs to the bucket after it.
+ */
+static int ocfs2_extend_xattr_bucket(struct inode *inode,
+                                     struct buffer_head *first_bh,
+                                     struct buffer_head *start_bh,
+                                     u32 num_clusters)
+{
+        int ret, credits;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        u64 start_blk = start_bh->b_blocknr, end_blk;
+        u32 num_buckets = num_clusters * ocfs2_xattr_buckets_per_cluster(osb);
+        handle_t *handle;
+        struct ocfs2_xattr_header *first_xh =
+                                (struct ocfs2_xattr_header *)first_bh->b_data;
+        u16 bucket = le16_to_cpu(first_xh->xh_num_buckets);
+        mlog(0, "extend xattr bucket in %llu, xattr extend rec starting "
+             "from %llu, len = %u\n", start_blk,
+             (unsigned long long)first_bh->b_blocknr, num_clusters);
+        BUG_ON(bucket >= num_buckets);
+        end_blk = first_bh->b_blocknr + (bucket - 1) * blk_per_bucket;
+        /*
+         * We will touch all the buckets after the start_bh(include it).
+         * Add one more bucket and modify the first_bh.
+         */
+        credits = end_blk - start_blk + 2 * blk_per_bucket + 1;
+        handle = ocfs2_start_trans(osb, credits);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                handle = NULL;
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, first_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto commit;
+        }
+        while (end_blk != start_blk) {
+                ret = ocfs2_cp_xattr_bucket(inode, handle, end_blk,
+                                            end_blk + blk_per_bucket, 0);
+                if (ret)
+                        goto commit;
+                end_blk -= blk_per_bucket;
+        }
+        /* Move half of the xattr in start_blk to the next bucket. */
+        ret = ocfs2_half_xattr_bucket(inode, handle, start_blk,
+                                      start_blk + blk_per_bucket, NULL, 0);
+        le16_add_cpu(&first_xh->xh_num_buckets, 1);
+        ocfs2_journal_dirty(handle, first_bh);
+commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        return ret;
+}
+/*
+ * Add new xattr bucket in an extent record and adjust the buckets accordingly.
+ * xb_bh is the ocfs2_xattr_block.
+ * We will move all the buckets starting from header_bh to the next place. As
+ * for this one, half num of its xattrs will be moved to the next one.
+ *
+ * We will allocate a new cluster if current cluster is full and adjust
+ * header_bh and first_bh if the insert place is moved to the new cluster.
+ */
+static int ocfs2_add_new_xattr_bucket(struct inode *inode,
+                                      struct buffer_head *xb_bh,
+                                      struct buffer_head *header_bh)
+{
+        struct ocfs2_xattr_header *first_xh = NULL;
+        struct buffer_head *first_bh = NULL;
+        struct ocfs2_xattr_block *xb =
+                        (struct ocfs2_xattr_block *)xb_bh->b_data;
+        struct ocfs2_xattr_tree_root *xb_root = &xb->xb_attrs.xb_root;
+        struct ocfs2_extent_list *el = &xb_root->xt_list;
+        struct ocfs2_xattr_header *xh =
+                        (struct ocfs2_xattr_header *)header_bh->b_data;
+        u32 name_hash = le32_to_cpu(xh->xh_entries[0].xe_name_hash);
+        struct super_block *sb = inode->i_sb;
+        struct ocfs2_super *osb = OCFS2_SB(sb);
+        int ret, num_buckets, extend = 1;
+        u64 p_blkno;
+        u32 e_cpos, num_clusters;
+        mlog(0, "Add new xattr bucket starting form %llu\n",
+             (unsigned long long)header_bh->b_blocknr);
+        /*
+         * Add refrence for header_bh here because it may be
+         * changed in ocfs2_add_new_xattr_cluster and we need
+         * to free it in the end.
+         */
+        get_bh(header_bh);
+        ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno, &e_cpos,
+                                  &num_clusters, el);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_read_block(inode, p_blkno, &first_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        num_buckets = ocfs2_xattr_buckets_per_cluster(osb) * num_clusters;
+        first_xh = (struct ocfs2_xattr_header *)first_bh->b_data;
+        if (num_buckets == le16_to_cpu(first_xh->xh_num_buckets)) {
+                ret = ocfs2_add_new_xattr_cluster(inode,
+                                                  xb_bh,
+                                                  &first_bh,
+                                                  &header_bh,
+                                                  &num_clusters,
+                                                  e_cpos,
+                                                  p_blkno,
+                                                  &extend);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        if (extend)
+                ret = ocfs2_extend_xattr_bucket(inode,
+                                                first_bh,
+                                                header_bh,
+                                                num_clusters);
+        if (ret)
+                mlog_errno(ret);
+out:
+        brelse(first_bh);
+        brelse(header_bh);
+        return ret;
+}
+static inline char *ocfs2_xattr_bucket_get_val(struct inode *inode,
+                                        struct ocfs2_xattr_bucket *bucket,
+                                        int offs)
+{
+        int block_off = offs >> inode->i_sb->s_blocksize_bits;
+        offs = offs % inode->i_sb->s_blocksize;
+        return bucket->bhs[block_off]->b_data + offs;
+}
+/*
+ * Handle the normal xattr set, including replace, delete and new.
+ *
+ * Note: "local" indicates the real data's locality. So we can't
+ * just its bucket locality by its length.
+ */
+static void ocfs2_xattr_set_entry_normal(struct inode *inode,
+                                         struct ocfs2_xattr_info *xi,
+                                         struct ocfs2_xattr_search *xs,
+                                         u32 name_hash,
+                                         int local)
+{
+        struct ocfs2_xattr_entry *last, *xe;
+        int name_len = strlen(xi->name);
+        struct ocfs2_xattr_header *xh = xs->header;
+        u16 count = le16_to_cpu(xh->xh_count), start;
+        size_t blocksize = inode->i_sb->s_blocksize;
+        char *val;
+        size_t offs, size, new_size;
+        last = &xh->xh_entries[count];
+        if (!xs->not_found) {
+                xe = xs->here;
+                offs = le16_to_cpu(xe->xe_name_offset);
+                if (ocfs2_xattr_is_local(xe))
+                        size = OCFS2_XATTR_SIZE(name_len) +
+                        OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
+                else
+                        size = OCFS2_XATTR_SIZE(name_len) +
+                        OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE);
+                /*
+                 * If the new value will be stored outside, xi->value has been
+                 * initalized as an empty ocfs2_xattr_value_root, and the same
+                 * goes with xi->value_len, so we can set new_size safely here.
+                 * See ocfs2_xattr_set_in_bucket.
+                 */
+                new_size = OCFS2_XATTR_SIZE(name_len) +
+                           OCFS2_XATTR_SIZE(xi->value_len);
+                le16_add_cpu(&xh->xh_name_value_len, -size);
+                if (xi->value) {
+                        if (new_size > size)
+                                goto set_new_name_value;
+                        /* Now replace the old value with new one. */
+                        if (local)
+                                xe->xe_value_size = cpu_to_le64(xi->value_len);
+                        else
+                                xe->xe_value_size = 0;
+                        val = ocfs2_xattr_bucket_get_val(inode,
+                                                         &xs->bucket, offs);
+                        memset(val + OCFS2_XATTR_SIZE(name_len), 0,
+                               size - OCFS2_XATTR_SIZE(name_len));
+                        if (OCFS2_XATTR_SIZE(xi->value_len) > 0)
+                                memcpy(val + OCFS2_XATTR_SIZE(name_len),
+                                       xi->value, xi->value_len);
+                        le16_add_cpu(&xh->xh_name_value_len, new_size);
+                        ocfs2_xattr_set_local(xe, local);
+                        return;
+                } else {
+                        /*
+                         * Remove the old entry if there is more than one.
+                         * We don't remove the last entry so that we can
+                         * use it to indicate the hash value of the empty
+                         * bucket.
+                         */
+                        last -= 1;
+                        le16_add_cpu(&xh->xh_count, -1);
+                        if (xh->xh_count) {
+                                memmove(xe, xe + 1,
+                                        (void *)last - (void *)xe);
+                                memset(last, 0,
+                                       sizeof(struct ocfs2_xattr_entry));
+                        } else
+                                xh->xh_free_start =
+                                        cpu_to_le16(OCFS2_XATTR_BUCKET_SIZE);
+                        return;
+                }
+        } else {
+                /* find a new entry for insert. */
+                int low = 0, high = count - 1, tmp;
+                struct ocfs2_xattr_entry *tmp_xe;
+                while (low <= high && count) {
+                        tmp = (low + high) / 2;
+                        tmp_xe = &xh->xh_entries[tmp];
+                        if (name_hash > le32_to_cpu(tmp_xe->xe_name_hash))
+                                low = tmp + 1;
+                        else if (name_hash <
+                                 le32_to_cpu(tmp_xe->xe_name_hash))
+                                high = tmp - 1;
+                        else {
+                                low = tmp;
+                                break;
+                        }
+                }
+                xe = &xh->xh_entries[low];
+                if (low != count)
+                        memmove(xe + 1, xe, (void *)last - (void *)xe);
+                le16_add_cpu(&xh->xh_count, 1);
+                memset(xe, 0, sizeof(struct ocfs2_xattr_entry));
+                xe->xe_name_hash = cpu_to_le32(name_hash);
+                xe->xe_name_len = name_len;
+                ocfs2_xattr_set_type(xe, xi->name_index);
+        }
+set_new_name_value:
+        /* Insert the new name+value. */
+        size = OCFS2_XATTR_SIZE(name_len) + OCFS2_XATTR_SIZE(xi->value_len);
+        /*
+         * We must make sure that the name/value pair
+         * exists in the same block.
+         */
+        offs = le16_to_cpu(xh->xh_free_start);
+        start = offs - size;
+        if (start >> inode->i_sb->s_blocksize_bits !=
+            (offs - 1) >> inode->i_sb->s_blocksize_bits) {
+                offs = offs - offs % blocksize;
+                xh->xh_free_start = cpu_to_le16(offs);
+        }
+        val = ocfs2_xattr_bucket_get_val(inode,
+                                         &xs->bucket, offs - size);
+        xe->xe_name_offset = cpu_to_le16(offs - size);
+        memset(val, 0, size);
+        memcpy(val, xi->name, name_len);
+        memcpy(val + OCFS2_XATTR_SIZE(name_len), xi->value, xi->value_len);
+        xe->xe_value_size = cpu_to_le64(xi->value_len);
+        ocfs2_xattr_set_local(xe, local);
+        xs->here = xe;
+        le16_add_cpu(&xh->xh_free_start, -size);
+        le16_add_cpu(&xh->xh_name_value_len, size);
+        return;
+}
+static int ocfs2_xattr_bucket_handle_journal(struct inode *inode,
+                                             handle_t *handle,
+                                             struct ocfs2_xattr_search *xs,
+                                             struct buffer_head **bhs,
+                                             u16 bh_num)
+{
+        int ret = 0, off, block_off;
+        struct ocfs2_xattr_entry *xe = xs->here;
+        /*
+         * First calculate all the blocks we should journal_access
+         * and journal_dirty. The first block should always be touched.
+         */
+        ret = ocfs2_journal_dirty(handle, bhs[0]);
+        if (ret)
+                mlog_errno(ret);
+        /* calc the data. */
+        off = le16_to_cpu(xe->xe_name_offset);
+        block_off = off >> inode->i_sb->s_blocksize_bits;
+        ret = ocfs2_journal_dirty(handle, bhs[block_off]);
+        if (ret)
+                mlog_errno(ret);
+        return ret;
+}
+/*
+ * Set the xattr entry in the specified bucket.
+ * The bucket is indicated by xs->bucket and it should have the enough
+ * space for the xattr insertion.
+ */
+static int ocfs2_xattr_set_entry_in_bucket(struct inode *inode,
+                                           struct ocfs2_xattr_info *xi,
+                                           struct ocfs2_xattr_search *xs,
+                                           u32 name_hash,
+                                           int local)
+{
+        int i, ret;
+        handle_t *handle = NULL;
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        mlog(0, "Set xattr entry len = %lu index = %d in bucket %llu\n",
+             (unsigned long)xi->value_len, xi->name_index,
+             (unsigned long long)xs->bucket.bhs[0]->b_blocknr);
+        if (!xs->bucket.bhs[1]) {
+                ret = ocfs2_read_blocks(inode,
+                                        xs->bucket.bhs[0]->b_blocknr + 1,
+                                        blk_per_bucket - 1, &xs->bucket.bhs[1],
+                                        OCFS2_BH_CACHED);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        handle = ocfs2_start_trans(osb, blk_per_bucket);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                handle = NULL;
+                mlog_errno(ret);
+                goto out;
+        }
+        for (i = 0; i < blk_per_bucket; i++) {
+                ret = ocfs2_journal_access(handle, inode, xs->bucket.bhs[i],
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        ocfs2_xattr_set_entry_normal(inode, xi, xs, name_hash, local);
+        /*Only dirty the blocks we have touched in set xattr. */
+        ret = ocfs2_xattr_bucket_handle_journal(inode, handle, xs,
+                                                xs->bucket.bhs, blk_per_bucket);
+        if (ret)
+                mlog_errno(ret);
+out:
+        ocfs2_commit_trans(osb, handle);
+        return ret;
+}
+static int ocfs2_xattr_value_update_size(struct inode *inode,
+                                         struct buffer_head *xe_bh,
+                                         struct ocfs2_xattr_entry *xe,
+                                         u64 new_size)
+{
+        int ret;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        handle_t *handle = NULL;
+        handle = ocfs2_start_trans(osb, 1);
+        if (handle == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, xe_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        xe->xe_value_size = cpu_to_le64(new_size);
+        ret = ocfs2_journal_dirty(handle, xe_bh);
+        if (ret < 0)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        return ret;
+}
+/*
+ * Truncate the specified xe_off entry in xattr bucket.
+ * bucket is indicated by header_bh and len is the new length.
+ * Both the ocfs2_xattr_value_root and the entry will be updated here.
+ *
+ * Copy the new updated xe and xe_value_root to new_xe and new_xv if needed.
+ */
+static int ocfs2_xattr_bucket_value_truncate(struct inode *inode,
+                                             struct buffer_head *header_bh,
+                                             int xe_off,
+                                             int len)
+{
+        int ret, offset;
+        u64 value_blk;
+        struct buffer_head *value_bh = NULL;
+        struct ocfs2_xattr_value_root *xv;
+        struct ocfs2_xattr_entry *xe;
+        struct ocfs2_xattr_header *xh =
+                        (struct ocfs2_xattr_header *)header_bh->b_data;
+        size_t blocksize = inode->i_sb->s_blocksize;
+        xe = &xh->xh_entries[xe_off];
+        BUG_ON(!xe || ocfs2_xattr_is_local(xe));
+        offset = le16_to_cpu(xe->xe_name_offset) +
+                 OCFS2_XATTR_SIZE(xe->xe_name_len);
+        value_blk = offset / blocksize;
+        /* We don't allow ocfs2_xattr_value to be stored in different block. */
+        BUG_ON(value_blk != (offset + OCFS2_XATTR_ROOT_SIZE - 1) / blocksize);
+        value_blk += header_bh->b_blocknr;
+        ret = ocfs2_read_block(inode, value_blk, &value_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        xv = (struct ocfs2_xattr_value_root *)
+                (value_bh->b_data + offset % blocksize);
+        mlog(0, "truncate %u in xattr bucket %llu to %d bytes.\n",
+             xe_off, (unsigned long long)header_bh->b_blocknr, len);
+        ret = ocfs2_xattr_value_truncate(inode, value_bh, xv, len);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_xattr_value_update_size(inode, header_bh, xe, len);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+out:
+        brelse(value_bh);
+        return ret;
+}
+static int ocfs2_xattr_bucket_value_truncate_xs(struct inode *inode,
+                                                struct ocfs2_xattr_search *xs,
+                                                int len)
+{
+        int ret, offset;
+        struct ocfs2_xattr_entry *xe = xs->here;
+        struct ocfs2_xattr_header *xh = (struct ocfs2_xattr_header *)xs->base;
+        BUG_ON(!xs->bucket.bhs[0] || !xe || ocfs2_xattr_is_local(xe));
+        offset = xe - xh->xh_entries;
+        ret = ocfs2_xattr_bucket_value_truncate(inode, xs->bucket.bhs[0],
+                                                offset, len);
+        if (ret)
+                mlog_errno(ret);
+        return ret;
+}
+static int ocfs2_xattr_bucket_set_value_outside(struct inode *inode,
+                                                struct ocfs2_xattr_search *xs,
+                                                char *val,
+                                                int value_len)
+{
+        int offset;
+        struct ocfs2_xattr_value_root *xv;
+        struct ocfs2_xattr_entry *xe = xs->here;
+        BUG_ON(!xs->base || !xe || ocfs2_xattr_is_local(xe));
+        offset = le16_to_cpu(xe->xe_name_offset) +
+                 OCFS2_XATTR_SIZE(xe->xe_name_len);
+        xv = (struct ocfs2_xattr_value_root *)(xs->base + offset);
+        return __ocfs2_xattr_set_value_outside(inode, xv, val, value_len);
+}
+static int ocfs2_rm_xattr_cluster(struct inode *inode,
+                                  struct buffer_head *root_bh,
+                                  u64 blkno,
+                                  u32 cpos,
+                                  u32 len)
+{
+        int ret;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct inode *tl_inode = osb->osb_tl_inode;
+        handle_t *handle;
+        struct ocfs2_xattr_block *xb =
+                        (struct ocfs2_xattr_block *)root_bh->b_data;
+        struct ocfs2_alloc_context *meta_ac = NULL;
+        struct ocfs2_cached_dealloc_ctxt dealloc;
+        struct ocfs2_extent_tree et;
+        ocfs2_init_xattr_tree_extent_tree(&et, inode, root_bh);
+        ocfs2_init_dealloc_ctxt(&dealloc);
+        mlog(0, "rm xattr extent rec at %u len = %u, start from %llu\n",
+             cpos, len, (unsigned long long)blkno);
+        ocfs2_remove_xattr_clusters_from_cache(inode, blkno, len);
+        ret = ocfs2_lock_allocators(inode, &et, 0, 1, NULL, &meta_ac);
+        if (ret) {
+                mlog_errno(ret);
+                return ret;
+        }
+        mutex_lock(&tl_inode->i_mutex);
+        if (ocfs2_truncate_log_needs_flush(osb)) {
+                ret = __ocfs2_flush_truncate_log(osb);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+        handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
+        if (handle == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+        ret = ocfs2_journal_access(handle, inode, root_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        ret = ocfs2_remove_extent(inode, &et, cpos, len, handle, meta_ac,
+                                  &dealloc);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, -len);
+        ret = ocfs2_journal_dirty(handle, root_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        ret = ocfs2_truncate_log_append(osb, handle, blkno, len);
+        if (ret)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        ocfs2_schedule_truncate_log_flush(osb, 1);
+        mutex_unlock(&tl_inode->i_mutex);
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+        ocfs2_run_deallocs(osb, &dealloc);
+        return ret;
+}
+static void ocfs2_xattr_bucket_remove_xs(struct inode *inode,
+                                         struct ocfs2_xattr_search *xs)
+{
+        handle_t *handle = NULL;
+        struct ocfs2_xattr_header *xh = xs->bucket.xh;
+        struct ocfs2_xattr_entry *last = &xh->xh_entries[
+                                                le16_to_cpu(xh->xh_count) - 1];
+        int ret = 0;
+        handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), 1);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                return;
+        }
+        ret = ocfs2_journal_access(handle, inode, xs->bucket.bhs[0],
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+        /* Remove the old entry. */
+        memmove(xs->here, xs->here + 1,
+                (void *)last - (void *)xs->here);
+        memset(last, 0, sizeof(struct ocfs2_xattr_entry));
+        le16_add_cpu(&xh->xh_count, -1);
+        ret = ocfs2_journal_dirty(handle, xs->bucket.bhs[0]);
+        if (ret < 0)
+                mlog_errno(ret);
+out_commit:
+        ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
+}
+/*
+ * Set the xattr name/value in the bucket specified in xs.
+ *
+ * As the new value in xi may be stored in the bucket or in an outside cluster,
+ * we divide the whole process into 3 steps:
+ * 1. insert name/value in the bucket(ocfs2_xattr_set_entry_in_bucket)
+ * 2. truncate of the outside cluster(ocfs2_xattr_bucket_value_truncate_xs)
+ * 3. Set the value to the outside cluster(ocfs2_xattr_bucket_set_value_outside)
+ * 4. If the clusters for the new outside value can't be allocated, we need
+ *    to free the xattr we allocated in set.
+ */
+static int ocfs2_xattr_set_in_bucket(struct inode *inode,
+                                     struct ocfs2_xattr_info *xi,
+                                     struct ocfs2_xattr_search *xs)
+{
+        int ret, local = 1;
+        size_t value_len;
+        char *val = (char *)xi->value;
+        struct ocfs2_xattr_entry *xe = xs->here;
+        u32 name_hash = ocfs2_xattr_name_hash(inode, xi->name,
+                                              strlen(xi->name));
+        if (!xs->not_found && !ocfs2_xattr_is_local(xe)) {
+                /*
+                 * We need to truncate the xattr storage first.
+                 *
+                 * If both the old and new value are stored to
+                 * outside block, we only need to truncate
+                 * the storage and then set the value outside.
+                 *
+                 * If the new value should be stored within block,
+                 * we should free all the outside block first and
+                 * the modification to the xattr block will be done
+                 * by following steps.
+                 */
+                if (xi->value_len > OCFS2_XATTR_INLINE_SIZE)
+                        value_len = xi->value_len;
+                else
+                        value_len = 0;
+                ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs,
+                                                           value_len);
+                if (ret)
+                        goto out;
+                if (value_len)
+                        goto set_value_outside;
+        }
+        value_len = xi->value_len;
+        /* So we have to handle the inside block change now. */
+        if (value_len > OCFS2_XATTR_INLINE_SIZE) {
+                /*
+                 * If the new value will be stored outside of block,
+                 * initalize a new empty value root and insert it first.
+                 */
+                local = 0;
+                xi->value = &def_xv;
+                xi->value_len = OCFS2_XATTR_ROOT_SIZE;
+        }
+        ret = ocfs2_xattr_set_entry_in_bucket(inode, xi, xs, name_hash, local);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        if (value_len <= OCFS2_XATTR_INLINE_SIZE)
+                goto out;
+        /* allocate the space now for the outside block storage. */
+        ret = ocfs2_xattr_bucket_value_truncate_xs(inode, xs,
+                                                   value_len);
+        if (ret) {
+                mlog_errno(ret);
+                if (xs->not_found) {
+                        /*
+                         * We can't allocate enough clusters for outside
+                         * storage and we have allocated xattr already,
+                         * so need to remove it.
+                         */
+                        ocfs2_xattr_bucket_remove_xs(inode, xs);
+                }
+                goto out;
+        }
+set_value_outside:
+        ret = ocfs2_xattr_bucket_set_value_outside(inode, xs, val, value_len);
+out:
+        return ret;
+}
+/* check whether the xattr bucket is filled up with the same hash value. */
+static int ocfs2_check_xattr_bucket_collision(struct inode *inode,
+                                              struct ocfs2_xattr_bucket *bucket)
+{
+        struct ocfs2_xattr_header *xh = bucket->xh;
+        if (xh->xh_entries[le16_to_cpu(xh->xh_count) - 1].xe_name_hash ==
+            xh->xh_entries[0].xe_name_hash) {
+                mlog(ML_ERROR, "Too much hash collision in xattr bucket %llu, "
+                     "hash = %u\n",
+                     (unsigned long long)bucket->bhs[0]->b_blocknr,
+                     le32_to_cpu(xh->xh_entries[0].xe_name_hash));
+                return -ENOSPC;
+        }
+        return 0;
+}
+static int ocfs2_xattr_set_entry_index_block(struct inode *inode,
+                                             struct ocfs2_xattr_info *xi,
+                                             struct ocfs2_xattr_search *xs)
+{
+        struct ocfs2_xattr_header *xh;
+        struct ocfs2_xattr_entry *xe;
+        u16 count, header_size, xh_free_start;
+        int i, free, max_free, need, old;
+        size_t value_size = 0, name_len = strlen(xi->name);
+        size_t blocksize = inode->i_sb->s_blocksize;
+        int ret, allocation = 0;
+        u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb);
+        mlog_entry("Set xattr %s in xattr index block\n", xi->name);
+try_again:
+        xh = xs->header;
+        count = le16_to_cpu(xh->xh_count);
+        xh_free_start = le16_to_cpu(xh->xh_free_start);
+        header_size = sizeof(struct ocfs2_xattr_header) +
+                        count * sizeof(struct ocfs2_xattr_entry);
+        max_free = OCFS2_XATTR_BUCKET_SIZE -
+                le16_to_cpu(xh->xh_name_value_len) - header_size;
+        mlog_bug_on_msg(header_size > blocksize, "bucket %llu has header size "
+                        "of %u which exceed block size\n",
+                        (unsigned long long)xs->bucket.bhs[0]->b_blocknr,
+                        header_size);
+        if (xi->value && xi->value_len > OCFS2_XATTR_INLINE_SIZE)
+                value_size = OCFS2_XATTR_ROOT_SIZE;
+        else if (xi->value)
+                value_size = OCFS2_XATTR_SIZE(xi->value_len);
+        if (xs->not_found)
+                need = sizeof(struct ocfs2_xattr_entry) +
+                        OCFS2_XATTR_SIZE(name_len) + value_size;
+        else {
+                need = value_size + OCFS2_XATTR_SIZE(name_len);
+                /*
+                 * We only replace the old value if the new length is smaller
+                 * than the old one. Otherwise we will allocate new space in the
+                 * bucket to store it.
+                 */
+                xe = xs->here;
+                if (ocfs2_xattr_is_local(xe))
+                        old = OCFS2_XATTR_SIZE(le64_to_cpu(xe->xe_value_size));
+                else
+                        old = OCFS2_XATTR_SIZE(OCFS2_XATTR_ROOT_SIZE);
+                if (old >= value_size)
+                        need = 0;
+        }
+        free = xh_free_start - header_size;
+        /*
+         * We need to make sure the new name/value pair
+         * can exist in the same block.
+         */
+        if (xh_free_start % blocksize < need)
+                free -= xh_free_start % blocksize;
+        mlog(0, "xs->not_found = %d, in xattr bucket %llu: free = %d, "
+             "need = %d, max_free = %d, xh_free_start = %u, xh_name_value_len ="
+             " %u\n", xs->not_found,
+             (unsigned long long)xs->bucket.bhs[0]->b_blocknr,
+             free, need, max_free, le16_to_cpu(xh->xh_free_start),
+             le16_to_cpu(xh->xh_name_value_len));
+        if (free < need || count == ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) {
+                if (need <= max_free &&
+                    count < ocfs2_xattr_max_xe_in_bucket(inode->i_sb)) {
+                        /*
+                         * We can create the space by defragment. Since only the
+                         * name/value will be moved, the xe shouldn't be changed
+                         * in xs.
+                         */
+                        ret = ocfs2_defrag_xattr_bucket(inode, &xs->bucket);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                        xh_free_start = le16_to_cpu(xh->xh_free_start);
+                        free = xh_free_start - header_size;
+                        if (xh_free_start % blocksize < need)
+                                free -= xh_free_start % blocksize;
+                        if (free >= need)
+                                goto xattr_set;
+                        mlog(0, "Can't get enough space for xattr insert by "
+                             "defragment. Need %u bytes, but we have %d, so "
+                             "allocate new bucket for it.\n", need, free);
+                }
+                /*
+                 * We have to add new buckets or clusters and one
+                 * allocation should leave us enough space for insert.
+                 */
+                BUG_ON(allocation);
+                /*
+                 * We do not allow for overlapping ranges between buckets. And
+                 * the maximum number of collisions we will allow for then is
+                 * one bucket's worth, so check it here whether we need to
+                 * add a new bucket for the insert.
+                 */
+                ret = ocfs2_check_xattr_bucket_collision(inode, &xs->bucket);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                ret = ocfs2_add_new_xattr_bucket(inode,
+                                                 xs->xattr_bh,
+                                                 xs->bucket.bhs[0]);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                for (i = 0; i < blk_per_bucket; i++)
+                        brelse(xs->bucket.bhs[i]);
+                memset(&xs->bucket, 0, sizeof(xs->bucket));
+                ret = ocfs2_xattr_index_block_find(inode, xs->xattr_bh,
+                                                   xi->name_index,
+                                                   xi->name, xs);
+                if (ret && ret != -ENODATA)
+                        goto out;
+                xs->not_found = ret;
+                allocation = 1;
+                goto try_again;
+        }
+xattr_set:
+        ret = ocfs2_xattr_set_in_bucket(inode, xi, xs);
+out:
+        mlog_exit(ret);
+        return ret;
+}
+static int ocfs2_delete_xattr_in_bucket(struct inode *inode,
+                                        struct ocfs2_xattr_bucket *bucket,
+                                        void *para)
+{
+        int ret = 0;
+        struct ocfs2_xattr_header *xh = bucket->xh;
+        u16 i;
+        struct ocfs2_xattr_entry *xe;
+        for (i = 0; i < le16_to_cpu(xh->xh_count); i++) {
+                xe = &xh->xh_entries[i];
+                if (ocfs2_xattr_is_local(xe))
+                        continue;
+                ret = ocfs2_xattr_bucket_value_truncate(inode,
+                                                        bucket->bhs[0],
+                                                        i, 0);
+                if (ret) {
+                        mlog_errno(ret);
+                        break;
+                }
+        }
+        return ret;
+}
+static int ocfs2_delete_xattr_index_block(struct inode *inode,
+                                          struct buffer_head *xb_bh)
+{
+        struct ocfs2_xattr_block *xb =
+                        (struct ocfs2_xattr_block *)xb_bh->b_data;
+        struct ocfs2_extent_list *el = &xb->xb_attrs.xb_root.xt_list;
+        int ret = 0;
+        u32 name_hash = UINT_MAX, e_cpos, num_clusters;
+        u64 p_blkno;
+        if (le16_to_cpu(el->l_next_free_rec) == 0)
+                return 0;
+        while (name_hash > 0) {
+                ret = ocfs2_xattr_get_rec(inode, name_hash, &p_blkno,
+                                          &e_cpos, &num_clusters, el);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                ret = ocfs2_iterate_xattr_buckets(inode, p_blkno, num_clusters,
+                                                  ocfs2_delete_xattr_in_bucket,
+                                                  NULL);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                ret = ocfs2_rm_xattr_cluster(inode, xb_bh,
+                                             p_blkno, e_cpos, num_clusters);
+                if (ret) {
+                        mlog_errno(ret);
+                        break;
+                }
+                if (e_cpos == 0)
+                        break;
+                name_hash = e_cpos - 1;
+        }
+out:
+        return ret;
+}
+/*
+ * 'trusted' attributes support
+ */
+#define XATTR_TRUSTED_PREFIX "trusted."
+static size_t ocfs2_xattr_trusted_list(struct inode *inode, char *list,
+                                       size_t list_size, const char *name,
+                                       size_t name_len)
+{
+        const size_t prefix_len = sizeof(XATTR_TRUSTED_PREFIX) - 1;
+        const size_t total_len = prefix_len + name_len + 1;
+        if (list && total_len <= list_size) {
+                memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len);
+                memcpy(list + prefix_len, name, name_len);
+                list[prefix_len + name_len] = '\0';
+        }
+        return total_len;
+}
+static int ocfs2_xattr_trusted_get(struct inode *inode, const char *name,
+                                   void *buffer, size_t size)
+{
+        if (strcmp(name, "") == 0)
+                return -EINVAL;
+        return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_TRUSTED, name,
+                               buffer, size);
+}
+static int ocfs2_xattr_trusted_set(struct inode *inode, const char *name,
+                                   const void *value, size_t size, int flags)
+{
+        if (strcmp(name, "") == 0)
+                return -EINVAL;
+        return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_TRUSTED, name, value,
+                               size, flags);
+}
+struct xattr_handler ocfs2_xattr_trusted_handler = {
+        .prefix = XATTR_TRUSTED_PREFIX,
+        .list   = ocfs2_xattr_trusted_list,
+        .get    = ocfs2_xattr_trusted_get,
+        .set    = ocfs2_xattr_trusted_set,
+};
+/*
+ * 'user' attributes support
+ */
+#define XATTR_USER_PREFIX "user."
+static size_t ocfs2_xattr_user_list(struct inode *inode, char *list,
+                                    size_t list_size, const char *name,
+                                    size_t name_len)
+{
+        const size_t prefix_len = sizeof(XATTR_USER_PREFIX) - 1;
+        const size_t total_len = prefix_len + name_len + 1;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
+                return 0;
+        if (list && total_len <= list_size) {
+                memcpy(list, XATTR_USER_PREFIX, prefix_len);
+                memcpy(list + prefix_len, name, name_len);
+                list[prefix_len + name_len] = '\0';
+        }
+        return total_len;
+}
+static int ocfs2_xattr_user_get(struct inode *inode, const char *name,
+                                void *buffer, size_t size)
+{
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        if (strcmp(name, "") == 0)
+                return -EINVAL;
+        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
+                return -EOPNOTSUPP;
+        return ocfs2_xattr_get(inode, OCFS2_XATTR_INDEX_USER, name,
+                               buffer, size);
+}
+static int ocfs2_xattr_user_set(struct inode *inode, const char *name,
+                                const void *value, size_t size, int flags)
+{
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        if (strcmp(name, "") == 0)
+                return -EINVAL;
+        if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
+                return -EOPNOTSUPP;
+        return ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_USER, name, value,
+                               size, flags);
+}
+struct xattr_handler ocfs2_xattr_user_handler = {
+        .prefix = XATTR_USER_PREFIX,
+        .list   = ocfs2_xattr_user_list,
+        .get    = ocfs2_xattr_user_get,
+        .set    = ocfs2_xattr_user_set,
+};
diff --git a/fs/ocfs2/xattr.h b/fs/ocfs2/xattr.h
new file mode 100644
index 000000000000..c25c7c62a059
--- /dev/null
+++ b/fs/ocfs2/xattr.h
@@ -0,0 +1,68 @@
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * xattr.h
+ *
+ * Function prototypes
+ *
+ * Copyright (C) 2008 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+#ifndef OCFS2_XATTR_H
+#define OCFS2_XATTR_H
+#include <linux/init.h>
+#include <linux/xattr.h>
+enum ocfs2_xattr_type {
+        OCFS2_XATTR_INDEX_USER = 1,
+        OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS,
+        OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT,
+        OCFS2_XATTR_INDEX_TRUSTED,
+        OCFS2_XATTR_INDEX_SECURITY,
+        OCFS2_XATTR_MAX
+};
+extern struct xattr_handler ocfs2_xattr_user_handler;
+extern struct xattr_handler ocfs2_xattr_trusted_handler;
+extern ssize_t ocfs2_listxattr(struct dentry *, char *, size_t);
+extern int ocfs2_xattr_get(struct inode *, int, const char *, void *, size_t);
+extern int ocfs2_xattr_set(struct inode *, int, const char *, const void *,
+                           size_t, int);
+extern int ocfs2_xattr_remove(struct inode *inode, struct buffer_head *di_bh);
+extern struct xattr_handler *ocfs2_xattr_handlers[];
+static inline u16 ocfs2_xattr_buckets_per_cluster(struct ocfs2_super *osb)
+{
+        return (1 << osb->s_clustersize_bits) / OCFS2_XATTR_BUCKET_SIZE;
+}
+static inline u16 ocfs2_blocks_per_xattr_bucket(struct super_block *sb)
+{
+        return OCFS2_XATTR_BUCKET_SIZE / (1 << sb->s_blocksize_bits);
+}
+static inline u16 ocfs2_xattr_max_xe_in_bucket(struct super_block *sb)
+{
+        u16 len = sb->s_blocksize -
+                 offsetof(struct ocfs2_xattr_header, xh_entries);
+        return len / sizeof(struct ocfs2_xattr_entry);
+}
+#endif /* OCFS2_XATTR_H */
diff --git a/include/linux/hid.h b/include/linux/hid.h
index ac4e678a04ed..f13bca2dd53b 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -67,6 +67,7 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/list.h>
+#include <linux/mod_devicetable.h> /* hid_device_id */
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/input.h>
@@ -246,6 +247,19 @@ struct hid_item {
 #define HID_FEATURE_REPORT      2
 /*
+ * HID connect requests
+ */
+#define HID_CONNECT_HIDINPUT            0x01
+#define HID_CONNECT_HIDINPUT_FORCE      0x02
+#define HID_CONNECT_HIDRAW              0x04
+#define HID_CONNECT_HIDDEV              0x08
+#define HID_CONNECT_HIDDEV_FORCE        0x10
+#define HID_CONNECT_FF                  0x20
+#define HID_CONNECT_DEFAULT     (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
+                HID_CONNECT_HIDDEV|HID_CONNECT_FF)
+/*
 * HID device quirks.
 */
@@ -256,48 +270,11 @@ struct hid_item {
 #define HID_QUIRK_INVERT                        0x00000001
 #define HID_QUIRK_NOTOUCH                       0x00000002
-#define HID_QUIRK_IGNORE                        0x00000004
 #define HID_QUIRK_NOGET                         0x00000008
-#define HID_QUIRK_HIDDEV                        0x00000010
 #define HID_QUIRK_BADPAD                        0x00000020
 #define HID_QUIRK_MULTI_INPUT                   0x00000040
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_7           0x00000080
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_5           0x00000100
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_ON          0x00000200
-#define HID_QUIRK_MIGHTYMOUSE                   0x00000400
-#define HID_QUIRK_APPLE_HAS_FN                  0x00000800
-#define HID_QUIRK_APPLE_FN_ON                   0x00001000
-#define HID_QUIRK_INVERT_HWHEEL                 0x00002000
-#define HID_QUIRK_APPLE_ISO_KEYBOARD            0x00004000
-#define HID_QUIRK_BAD_RELATIVE_KEYS             0x00008000
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS           0x00010000
-#define HID_QUIRK_IGNORE_MOUSE                  0x00020000
-#define HID_QUIRK_SONY_PS3_CONTROLLER           0x00040000
-#define HID_QUIRK_DUPLICATE_USAGES              0x00080000
-#define HID_QUIRK_RESET_LEDS                    0x00100000
-#define HID_QUIRK_HIDINPUT                      0x00200000
-#define HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL 0x00400000
-#define HID_QUIRK_LOGITECH_EXPANDED_KEYMAP      0x00800000
-#define HID_QUIRK_IGNORE_HIDINPUT               0x01000000
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_B8          0x02000000
-#define HID_QUIRK_HWHEEL_WHEEL_INVERT           0x04000000
-#define HID_QUIRK_MICROSOFT_KEYS                0x08000000
 #define HID_QUIRK_FULLSPEED_INTERVAL            0x10000000
-#define HID_QUIRK_APPLE_NUMLOCK_EMULATION       0x20000000
-/*
- * Separate quirks for runtime report descriptor fixup
- */
-#define HID_QUIRK_RDESC_CYMOTION                0x00000001
-#define HID_QUIRK_RDESC_LOGITECH                0x00000002
-#define HID_QUIRK_RDESC_SWAPPED_MIN_MAX         0x00000004
-#define HID_QUIRK_RDESC_PETALYNX                0x00000008
-#define HID_QUIRK_RDESC_MACBOOK_JIS             0x00000010
-#define HID_QUIRK_RDESC_BUTTON_CONSUMER         0x00000020
-#define HID_QUIRK_RDESC_SAMSUNG_REMOTE          0x00000040
-#define HID_QUIRK_RDESC_MICROSOFT_RECV_1028     0x00000080
-#define HID_QUIRK_RDESC_SUNPLUS_WDESKTOP        0x00000100
 /*
 * This is the global environment of the parser. This information is
@@ -411,12 +388,21 @@ struct hid_report_enum {
 struct hid_control_fifo {
        unsigned char dir;
        struct hid_report *report;
+        char *raw_report;
+};
+struct hid_output_fifo {
+        struct hid_report *report;
+        char *raw_report;
 };
 #define HID_CLAIMED_INPUT       1
 #define HID_CLAIMED_HIDDEV      2
 #define HID_CLAIMED_HIDRAW      4
+#define HID_STAT_ADDED          1
+#define HID_STAT_PARSED         2
 #define HID_CTRL_RUNNING        1
 #define HID_OUT_RUNNING         2
 #define HID_IN_RUNNING          3
@@ -431,22 +417,28 @@ struct hid_input {
        struct input_dev *input;
 };
+struct hid_driver;
+struct hid_ll_driver;
 struct hid_device {                                                     /* device report descriptor */
-         __u8 *rdesc;
+        __u8 *rdesc;
        unsigned rsize;
        struct hid_collection *collection;                              /* List of HID collections */
        unsigned collection_size;                                       /* Number of allocated hid_collections */
        unsigned maxcollection;                                         /* Number of parsed collections */
        unsigned maxapplication;                                        /* Number of applications */
-        unsigned short bus;                                             /* BUS ID */
+        __u16 bus;                                                      /* BUS ID */
-        unsigned short vendor;                                          /* Vendor ID */
+        __u32 vendor;                                                   /* Vendor ID */
-        unsigned short product;                                         /* Product ID */
+        __u32 product;                                                  /* Product ID */
-        unsigned version;                                               /* HID version */
+        __u32 version;                                                  /* HID version */
        unsigned country;                                               /* HID country */
        struct hid_report_enum report_enum[HID_REPORT_TYPES];
-        struct device *dev;                                             /* device */
+        struct device dev;                                              /* device */
+        struct hid_driver *driver;
+        struct hid_ll_driver *ll_driver;
+        unsigned int status;                                            /* see STAT flags above */
        unsigned claimed;                                               /* Claimed by hidinput, hiddev? */
        unsigned quirks;                                                /* Various quirks the device can pull on us */
@@ -462,26 +454,29 @@ struct hid_device {							/* device report descriptor */
        void *driver_data;
-        __s32 delayed_value;                                            /* For A4 Tech mice hwheel quirk */
+        /* temporary hid_ff handling (until moved to the drivers) */
+        int (*ff_init)(struct hid_device *);
-        /* device-specific function pointers */
-        int (*hidinput_input_event) (struct input_dev *, unsigned int, unsigned int, int);
-        int (*hid_open) (struct hid_device *);
-        void (*hid_close) (struct hid_device *);
        /* hiddev event handler */
+        int (*hiddev_connect)(struct hid_device *, unsigned int);
        void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
                                  struct hid_usage *, __s32);
        void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
        /* handler for raw output data, used by hidraw */
        int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t);
-#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
-        unsigned long apple_pressed_fn[BITS_TO_LONGS(KEY_CNT)];
-        unsigned long pb_pressed_numlock[BITS_TO_LONGS(KEY_CNT)];
-#endif
 };
+static inline void *hid_get_drvdata(struct hid_device *hdev)
+{
+        return dev_get_drvdata(&hdev->dev);
+}
+static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
+{
+        dev_set_drvdata(&hdev->dev, data);
+}
 #define HID_GLOBAL_STACK_SIZE 4
 #define HID_COLLECTION_STACK_SIZE 4
@@ -510,6 +505,107 @@ struct hid_descriptor {
        struct hid_class_descriptor desc[1];
 } __attribute__ ((packed));
+#define HID_DEVICE(b, ven, prod) \
+        .bus = (b), \
+        .vendor = (ven), .product = (prod)
+#define HID_USB_DEVICE(ven, prod)       HID_DEVICE(BUS_USB, ven, prod)
+#define HID_BLUETOOTH_DEVICE(ven, prod) HID_DEVICE(BUS_BLUETOOTH, ven, prod)
+#define HID_REPORT_ID(rep) \
+        .report_type = (rep)
+#define HID_USAGE_ID(uhid, utype, ucode) \
+        .usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
+/* we don't want to catch types and codes equal to 0 */
+#define HID_TERMINATOR          (HID_ANY_ID - 1)
+struct hid_report_id {
+        __u32 report_type;
+};
+struct hid_usage_id {
+        __u32 usage_hid;
+        __u32 usage_type;
+        __u32 usage_code;
+};
+/**
+ * struct hid_driver
+ * @name: driver name (e.g. "Footech_bar-wheel")
+ * @id_table: which devices is this driver for (must be non-NULL for probe
+ *            to be called)
+ * @probe: new device inserted
+ * @remove: device removed (NULL if not a hot-plug capable driver)
+ * @report_table: on which reports to call raw_event (NULL means all)
+ * @raw_event: if report in report_table, this hook is called (NULL means nop)
+ * @usage_table: on which events to call event (NULL means all)
+ * @event: if usage in usage_table, this hook is called (NULL means nop)
+ * @report_fixup: called before report descriptor parsing (NULL means nop)
+ * @input_mapping: invoked on input registering before mapping an usage
+ * @input_mapped: invoked on input registering after mapping an usage
+ *
+ * raw_event and event should return 0 on no action performed, 1 when no
+ * further processing should be done and negative on error
+ *
+ * input_mapping shall return a negative value to completely ignore this usage
+ * (e.g. doubled or invalid usage), zero to continue with parsing of this
+ * usage by generic code (no special handling needed) or positive to skip
+ * generic parsing (needed special handling which was done in the hook already)
+ * input_mapped shall return negative to inform the layer that this usage
+ * should not be considered for further processing or zero to notify that
+ * no processing was performed and should be done in a generic manner
+ * Both these functions may be NULL which means the same behavior as returning
+ * zero from them.
+ */
+struct hid_driver {
+        char *name;
+        const struct hid_device_id *id_table;
+        int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
+        void (*remove)(struct hid_device *dev);
+        const struct hid_report_id *report_table;
+        int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
+                        u8 *data, int size);
+        const struct hid_usage_id *usage_table;
+        int (*event)(struct hid_device *hdev, struct hid_field *field,
+                        struct hid_usage *usage, __s32 value);
+        void (*report_fixup)(struct hid_device *hdev, __u8 *buf,
+                        unsigned int size);
+        int (*input_mapping)(struct hid_device *hdev,
+                        struct hid_input *hidinput, struct hid_field *field,
+                        struct hid_usage *usage, unsigned long **bit, int *max);
+        int (*input_mapped)(struct hid_device *hdev,
+                        struct hid_input *hidinput, struct hid_field *field,
+                        struct hid_usage *usage, unsigned long **bit, int *max);
+/* private: */
+        struct device_driver driver;
+};
+/**
+ * hid_ll_driver - low level driver callbacks
+ * @start: called on probe to start the device
+ * @stop: called on remove
+ * @open: called by input layer on open
+ * @close: called by input layer on close
+ * @hidinput_input_event: event input event (e.g. ff or leds)
+ * @parse: this method is called only once to parse the device data,
+ *         shouldn't allocate anything to not leak memory
+ */
+struct hid_ll_driver {
+        int (*start)(struct hid_device *hdev);
+        void (*stop)(struct hid_device *hdev);
+        int (*open)(struct hid_device *hdev);
+        void (*close)(struct hid_device *hdev);
+        int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
+                        unsigned int code, int value);
+        int (*parse)(struct hid_device *hdev);
+};
 /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
 /* We ignore a few input applications that are not widely used */
 #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || (a == 0x000d0002))
@@ -520,43 +616,157 @@ struct hid_descriptor {
 extern int hid_debug;
 #endif
+extern int hid_add_device(struct hid_device *);
+extern void hid_destroy_device(struct hid_device *);
+extern int __must_check __hid_register_driver(struct hid_driver *,
+                struct module *, const char *mod_name);
+static inline int __must_check hid_register_driver(struct hid_driver *driver)
+{
+        return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
+}
+extern void hid_unregister_driver(struct hid_driver *);
 extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
 extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
-extern int hidinput_connect(struct hid_device *);
+extern int hidinput_connect(struct hid_device *hid, unsigned int force);
 extern void hidinput_disconnect(struct hid_device *);
 int hid_set_field(struct hid_field *, unsigned, __s32);
 int hid_input_report(struct hid_device *, int type, u8 *, int, int);
 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
-int hidinput_mapping_quirks(struct hid_usage *, struct input_dev *, unsigned long **, int *);
-int hidinput_event_quirks(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
-int hidinput_apple_event(struct hid_device *, struct input_dev *, struct hid_usage *, __s32);
 void hid_output_report(struct hid_report *report, __u8 *data);
-void hid_free_device(struct hid_device *device);
+struct hid_device *hid_allocate_device(void);
-struct hid_device *hid_parse_report(__u8 *start, unsigned size);
+int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
+int hid_connect(struct hid_device *hid, unsigned int connect_mask);
+/**
+ * hid_map_usage - map usage input bits
+ *
+ * @hidinput: hidinput which we are interested in
+ * @usage: usage to fill in
+ * @bit: pointer to input->{}bit (out parameter)
+ * @max: maximal valid usage->code to consider later (out parameter)
+ * @type: input event type (EV_KEY, EV_REL, ...)
+ * @c: code which corresponds to this usage and type
+ */
+static inline void hid_map_usage(struct hid_input *hidinput,
+                struct hid_usage *usage, unsigned long **bit, int *max,
+                __u8 type, __u16 c)
+{
+        struct input_dev *input = hidinput->input;
+        usage->type = type;
+        usage->code = c;
+        switch (type) {
+        case EV_ABS:
+                *bit = input->absbit;
+                *max = ABS_MAX;
+                break;
+        case EV_REL:
+                *bit = input->relbit;
+                *max = REL_MAX;
+                break;
+        case EV_KEY:
+                *bit = input->keybit;
+                *max = KEY_MAX;
+                break;
+        case EV_LED:
+                *bit = input->ledbit;
+                *max = LED_MAX;
+                break;
+        }
+}
+/**
+ * hid_map_usage_clear - map usage input bits and clear the input bit
+ *
+ * The same as hid_map_usage, except the @c bit is also cleared in supported
+ * bits (@bit).
+ */
+static inline void hid_map_usage_clear(struct hid_input *hidinput,
+                struct hid_usage *usage, unsigned long **bit, int *max,
+                __u8 type, __u16 c)
+{
+        hid_map_usage(hidinput, usage, bit, max, type, c);
+        clear_bit(c, *bit);
+}
+/**
+ * hid_parse - parse HW reports
+ *
+ * @hdev: hid device
+ *
+ * Call this from probe after you set up the device (if needed). Your
+ * report_fixup will be called (if non-NULL) after reading raw report from
+ * device before passing it to hid layer for real parsing.
+ */
+static inline int __must_check hid_parse(struct hid_device *hdev)
+{
+        int ret;
+        if (hdev->status & HID_STAT_PARSED)
+                return 0;
+        ret = hdev->ll_driver->parse(hdev);
+        if (!ret)
+                hdev->status |= HID_STAT_PARSED;
+        return ret;
+}
+/**
+ * hid_hw_start - start underlaying HW
+ *
+ * @hdev: hid device
+ * @connect_mask: which outputs to connect, see HID_CONNECT_*
+ *
+ * Call this in probe function *after* hid_parse. This will setup HW buffers
+ * and start the device (if not deffered to device open). hid_hw_stop must be
+ * called if this was successfull.
+ */
+static inline int __must_check hid_hw_start(struct hid_device *hdev,
+                unsigned int connect_mask)
+{
+        int ret = hdev->ll_driver->start(hdev);
+        if (ret || !connect_mask)
+                return ret;
+        ret = hid_connect(hdev, connect_mask);
+        if (ret)
+                hdev->ll_driver->stop(hdev);
+        return ret;
+}
+/**
+ * hid_hw_stop - stop underlaying HW
+ *
+ * @hdev: hid device
+ *
+ * This is usually called from remove function or from probe when something
+ * failed and hid_hw_start was called already.
+ */
+static inline void hid_hw_stop(struct hid_device *hdev)
+{
+        hdev->ll_driver->stop(hdev);
+}
+void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
+                int interrupt);
+extern int hid_generic_init(void);
+extern void hid_generic_exit(void);
 /* HID quirks API */
 u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
 int usbhid_quirks_init(char **quirks_param);
 void usbhid_quirks_exit(void);
-void usbhid_fixup_report_descriptor(const u16, const u16, char *, unsigned, char **);
+void usbhid_set_leds(struct hid_device *hid);
-#ifdef CONFIG_HID_FF
-int hid_ff_init(struct hid_device *hid);
-int hid_lgff_init(struct hid_device *hid);
-int hid_lg2ff_init(struct hid_device *hid);
-int hid_plff_init(struct hid_device *hid);
-int hid_tmff_init(struct hid_device *hid);
-int hid_zpff_init(struct hid_device *hid);
 #ifdef CONFIG_HID_PID
 int hid_pidff_init(struct hid_device *hid);
 #else
-static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; }
+#define hid_pidff_init NULL
-#endif
-#else
-static inline int hid_ff_init(struct hid_device *hid) { return -1; }
 #endif
 #ifdef CONFIG_HID_DEBUG
@@ -572,10 +782,23 @@ dbg_hid(const char *fmt, ...)
        return 0;
 }
 #define dbg_hid_line dbg_hid
-#endif
+#endif /* HID_DEBUG */
 #define err_hid(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
                __FILE__ , ## arg)
-#endif
+#endif /* HID_FF */
+#ifdef CONFIG_HID_COMPAT
+#define HID_COMPAT_LOAD_DRIVER(name)    \
+void hid_compat_##name(void) { }        \
+EXPORT_SYMBOL(hid_compat_##name)
+#else
+#define HID_COMPAT_LOAD_DRIVER(name)
+#endif /* HID_COMPAT */
+#define HID_COMPAT_CALL_DRIVER(name)    do {    \
+        extern void hid_compat_##name(void);    \
+        hid_compat_##name();                    \
+} while (0)
 #endif
diff --git a/include/linux/hiddev.h b/include/linux/hiddev.h
index a416b904ba90..c760ae0eb6a1 100644
--- a/include/linux/hiddev.h
+++ b/include/linux/hiddev.h
@@ -182,26 +182,28 @@ struct hiddev_usage_ref_multi {
 /* To traverse the input report descriptor info for a HID device, perform the 
 * following:
 *
- *  rinfo.report_type = HID_REPORT_TYPE_INPUT;
+ * rinfo.report_type = HID_REPORT_TYPE_INPUT;
- *  rinfo.report_id = HID_REPORT_ID_FIRST;
+ * rinfo.report_id = HID_REPORT_ID_FIRST;
- *  ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ * ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
 *
- *  while (ret >= 0) {
+ * while (ret >= 0) {
- *      for (i = 0; i < rinfo.num_fields; i++) { 
+ *      for (i = 0; i < rinfo.num_fields; i++) {
- *          finfo.report_type = rinfo.report_type;
+ *              finfo.report_type = rinfo.report_type;
- *          finfo.report_id = rinfo.report_id;
+ *              finfo.report_id = rinfo.report_id;
- *          finfo.field_index = i;
+ *              finfo.field_index = i;
- *          ioctl(fd, HIDIOCGFIELDINFO, &finfo);
+ *              ioctl(fd, HIDIOCGFIELDINFO, &finfo);
- *          for (j = 0; j < finfo.maxusage; j++) {
+ *              for (j = 0; j < finfo.maxusage; j++) {
- *              uref.field_index = i;
+ *                      uref.report_type = rinfo.report_type;
- *              uref.usage_index = j;
+ *                      uref.report_id = rinfo.report_id;
- *              ioctl(fd, HIDIOCGUCODE, &uref);
+ *                      uref.field_index = i;
- *              ioctl(fd, HIDIOCGUSAGE, &uref);
+ *                      uref.usage_index = j;
- *          }
+ *                      ioctl(fd, HIDIOCGUCODE, &uref);
- *      }
+ *                      ioctl(fd, HIDIOCGUSAGE, &uref);
- *      rinfo.report_id |= HID_REPORT_ID_NEXT;
+ *              }
- *      ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ *      }
- *  }
+ *      rinfo.report_id |= HID_REPORT_ID_NEXT;
+ *      ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ * }
 */
@@ -217,7 +219,7 @@ struct hid_field;
 struct hid_report;
 #ifdef CONFIG_USB_HIDDEV
-int hiddev_connect(struct hid_device *);
+int hiddev_connect(struct hid_device *hid, unsigned int force);
 void hiddev_disconnect(struct hid_device *);
 void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
                      struct hid_usage *usage, __s32 value);
@@ -225,7 +227,9 @@ void hiddev_report_event(struct hid_device *hid, struct hid_report *report);
 int __init hiddev_init(void);
 void hiddev_exit(void);
 #else
-static inline int hiddev_connect(struct hid_device *hid) { return -1; }
+static inline int hiddev_connect(struct hid_device *hid,
+                unsigned int force)
+{ return -1; }
 static inline void hiddev_disconnect(struct hid_device *hid) { }
 static inline void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
                      struct hid_usage *usage, __s32 value) { }
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 3481a7d5bc0a..d6a3f47e95cb 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -131,6 +131,16 @@ struct usb_device_id {
 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100
 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200
+#define HID_ANY_ID                              (~0)
+struct hid_device_id {
+        __u16 bus;
+        __u32 vendor;
+        __u32 product;
+        kernel_ulong_t driver_data
+                __attribute__((aligned(sizeof(kernel_ulong_t))));
+};
 /* s390 CCW devices */
 struct ccw_device_id {
        __u16   match_flags;    /* which fields to match against */
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 96434d774c84..acdeab3d9807 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -578,7 +578,7 @@ static int hidp_session(void *arg)
        if (session->hid) {
                if (session->hid->claimed & HID_CLAIMED_INPUT)
                        hidinput_disconnect(session->hid);
-                hid_free_device(session->hid);
+                hid_destroy_device(session->hid);
        }
        /* Wakeup user-space polling for socket errors */
@@ -623,9 +623,15 @@ static struct device *hidp_get_device(struct hidp_session *session)
 static int hidp_setup_input(struct hidp_session *session,
                                struct hidp_connadd_req *req)
 {
-        struct input_dev *input = session->input;
+        struct input_dev *input;
        int i;
+        input = input_allocate_device();
+        if (!input)
+                return -ENOMEM;
+        session->input = input;
        input_set_drvdata(input, session);
        input->name = "Bluetooth HID Boot Protocol Device";
@@ -677,67 +683,114 @@ static void hidp_close(struct hid_device *hid)
 {
 }
-static const struct {
+static int hidp_parse(struct hid_device *hid)
-        __u16 idVendor;
+{
-        __u16 idProduct;
+        struct hidp_session *session = hid->driver_data;
-        unsigned quirks;
+        struct hidp_connadd_req *req = session->req;
-} hidp_blacklist[] = {
+        unsigned char *buf;
-        /* Apple wireless Mighty Mouse */
+        int ret;
-        { 0x05ac, 0x030c, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL },
-        { }     /* Terminating entry */
+        buf = kmalloc(req->rd_size, GFP_KERNEL);
-};
+        if (!buf)
+                return -ENOMEM;
+        if (copy_from_user(buf, req->rd_data, req->rd_size)) {
+                kfree(buf);
+                return -EFAULT;
+        }
+        ret = hid_parse_report(session->hid, buf, req->rd_size);
+        kfree(buf);
+        if (ret)
+                return ret;
+        session->req = NULL;
+        return 0;
+}
+static int hidp_start(struct hid_device *hid)
+{
+        struct hidp_session *session = hid->driver_data;
+        struct hid_report *report;
-static void hidp_setup_quirks(struct hid_device *hid)
+        list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].
+                        report_list, list)
+                hidp_send_report(session, report);
+        list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].
+                        report_list, list)
+                hidp_send_report(session, report);
+        return 0;
+}
+static void hidp_stop(struct hid_device *hid)
 {
-        unsigned int n;
+        struct hidp_session *session = hid->driver_data;
+        skb_queue_purge(&session->ctrl_transmit);
+        skb_queue_purge(&session->intr_transmit);
-        for (n = 0; hidp_blacklist[n].idVendor; n++)
+        if (hid->claimed & HID_CLAIMED_INPUT)
-                if (hidp_blacklist[n].idVendor == le16_to_cpu(hid->vendor) &&
+                hidinput_disconnect(hid);
-                                hidp_blacklist[n].idProduct == le16_to_cpu(hid->product))
+        hid->claimed = 0;
-                        hid->quirks = hidp_blacklist[n].quirks;
 }
-static void hidp_setup_hid(struct hidp_session *session,
+static struct hid_ll_driver hidp_hid_driver = {
+        .parse = hidp_parse,
+        .start = hidp_start,
+        .stop = hidp_stop,
+        .open  = hidp_open,
+        .close = hidp_close,
+        .hidinput_input_event = hidp_hidinput_event,
+};
+static int hidp_setup_hid(struct hidp_session *session,
                                struct hidp_connadd_req *req)
 {
-        struct hid_device *hid = session->hid;
+        struct hid_device *hid;
-        struct hid_report *report;
        bdaddr_t src, dst;
+        int ret;
-        baswap(&src, &bt_sk(session->ctrl_sock->sk)->src);
+        hid = hid_allocate_device();
-        baswap(&dst, &bt_sk(session->ctrl_sock->sk)->dst);
+        if (IS_ERR(hid)) {
+                ret = PTR_ERR(session->hid);
+                goto err;
+        }
+        session->hid = hid;
+        session->req = req;
        hid->driver_data = session;
-        hid->country = req->country;
+        baswap(&src, &bt_sk(session->ctrl_sock->sk)->src);
+        baswap(&dst, &bt_sk(session->ctrl_sock->sk)->dst);
        hid->bus     = BUS_BLUETOOTH;
        hid->vendor  = req->vendor;
        hid->product = req->product;
        hid->version = req->version;
+        hid->country = req->country;
        strncpy(hid->name, req->name, 128);
        strncpy(hid->phys, batostr(&src), 64);
        strncpy(hid->uniq, batostr(&dst), 64);
-        hid->dev = hidp_get_device(session);
+        hid->dev.parent = hidp_get_device(session);
+        hid->ll_driver = &hidp_hid_driver;
-        hid->hid_open  = hidp_open;
-        hid->hid_close = hidp_close;
-        hid->hidinput_input_event = hidp_hidinput_event;
-        hidp_setup_quirks(hid);
+        ret = hid_add_device(hid);
+        if (ret)
+                goto err_hid;
-        list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
+        return 0;
-                hidp_send_report(session, report);
+err_hid:
+        hid_destroy_device(hid);
-        list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
+        session->hid = NULL;
-                hidp_send_report(session, report);
+err:
+        return ret;
-        if (hidinput_connect(hid) == 0)
-                hid->claimed |= HID_CLAIMED_INPUT;
 }
 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
@@ -757,38 +810,6 @@ int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock,
        BT_DBG("rd_data %p rd_size %d", req->rd_data, req->rd_size);
-        if (req->rd_size > 0) {
-                unsigned char *buf = kmalloc(req->rd_size, GFP_KERNEL);
-                if (!buf) {
-                        kfree(session);
-                        return -ENOMEM;
-                }
-                if (copy_from_user(buf, req->rd_data, req->rd_size)) {
-                        kfree(buf);
-                        kfree(session);
-                        return -EFAULT;
-                }
-                session->hid = hid_parse_report(buf, req->rd_size);
-                kfree(buf);
-                if (!session->hid) {
-                        kfree(session);
-                        return -EINVAL;
-                }
-        }
-        if (!session->hid) {
-                session->input = input_allocate_device();
-                if (!session->input) {
-                        kfree(session);
-                        return -ENOMEM;
-                }
-        }
        down_write(&hidp_session_sem);
        s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
@@ -816,15 +837,18 @@ int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock,
        session->flags   = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
        session->idle_to = req->idle_to;
-        if (session->input) {
+        if (req->rd_size > 0) {
+                err = hidp_setup_hid(session, req);
+                if (err && err != -ENODEV)
+                        goto err_skb;
+        }
+        if (!session->hid) {
                err = hidp_setup_input(session, req);
                if (err < 0)
-                        goto failed;
+                        goto err_skb;
        }
-        if (session->hid)
-                hidp_setup_hid(session, req);
        __hidp_link_session(session);
        hidp_set_timer(session);
@@ -850,17 +874,16 @@ unlink:
        __hidp_unlink_session(session);
-        if (session->input) {
+        if (session->input)
                input_unregister_device(session->input);
-                session->input = NULL; /* don't try to free it here */
+        if (session->hid)
-        }
+                hid_destroy_device(session->hid);
+err_skb:
+        skb_queue_purge(&session->ctrl_transmit);
+        skb_queue_purge(&session->intr_transmit);
 failed:
        up_write(&hidp_session_sem);
-        if (session->hid)
-                hid_free_device(session->hid);
        input_free_device(session->input);
        kfree(session);
        return err;
@@ -950,18 +973,43 @@ int hidp_get_conninfo(struct hidp_conninfo *ci)
        return err;
 }
+static const struct hid_device_id hidp_table[] = {
+        { HID_BLUETOOTH_DEVICE(HID_ANY_ID, HID_ANY_ID) },
+        { }
+};
+static struct hid_driver hidp_driver = {
+        .name = "generic-bluetooth",
+        .id_table = hidp_table,
+};
 static int __init hidp_init(void)
 {
+        int ret;
        l2cap_load();
        BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
-        return hidp_init_sockets();
+        ret = hid_register_driver(&hidp_driver);
+        if (ret)
+                goto err;
+        ret = hidp_init_sockets();
+        if (ret)
+                goto err_drv;
+        return 0;
+err_drv:
+        hid_unregister_driver(&hidp_driver);
+err:
+        return ret;
 }
 static void __exit hidp_exit(void)
 {
        hidp_cleanup_sockets();
+        hid_unregister_driver(&hidp_driver);
 }
 module_init(hidp_init);
diff --git a/net/bluetooth/hidp/hidp.h b/net/bluetooth/hidp/hidp.h
index 343fb0566b3e..e503c89057ad 100644
--- a/net/bluetooth/hidp/hidp.h
+++ b/net/bluetooth/hidp/hidp.h
@@ -151,6 +151,8 @@ struct hidp_session {
        struct sk_buff_head ctrl_transmit;
        struct sk_buff_head intr_transmit;
+        struct hidp_connadd_req *req;
 };
 static inline void hidp_schedule(struct hidp_session *session)
diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
index 473f94e56ead..d4dc222a74f3 100644
--- a/scripts/mod/file2alias.c
+++ b/scripts/mod/file2alias.c
@@ -206,6 +206,20 @@ static void do_usb_table(void *symval, unsigned long size,
                do_usb_entry_multi(symval + i, mod);
 }
+/* Looks like: hid:bNvNpN */
+static int do_hid_entry(const char *filename,
+                             struct hid_device_id *id, char *alias)
+{
+        id->vendor = TO_NATIVE(id->vendor);
+        id->product = TO_NATIVE(id->product);
+        sprintf(alias, "hid:b%04X", id->bus);
+        ADD(alias, "v", id->vendor != HID_ANY_ID, id->vendor);
+        ADD(alias, "p", id->product != HID_ANY_ID, id->product);
+        return 1;
+}
 /* Looks like: ieee1394:venNmoNspNverN */
 static int do_ieee1394_entry(const char *filename,
                             struct ieee1394_device_id *id, char *alias)
@@ -745,6 +759,10 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
        else if (sym_is(symname, "__mod_usb_device_table"))
                /* special case to handle bcdDevice ranges */
                do_usb_table(symval, sym->st_size, mod);
+        else if (sym_is(symname, "__mod_hid_device_table"))
+                do_table(symval, sym->st_size,
+                         sizeof(struct hid_device_id), "hid",
+                         do_hid_entry, mod);
        else if (sym_is(symname, "__mod_ieee1394_device_table"))
                do_table(symval, sym->st_size,
                         sizeof(struct ieee1394_device_id), "ieee1394",