352 files changed, 17816 insertions, 5691 deletions

diff --git a/drivers/acorn/char/pcf8583.c b/drivers/acorn/char/pcf8583.c
index 2b850e5860a0..e26f007a1417 100644
--- a/drivers/acorn/char/pcf8583.c
+++ b/drivers/acorn/char/pcf8583.c
@@ -9,6 +9,7 @@
  *
  *  Driver for PCF8583 RTC & RAM chip
  */
+#include <linux/module.h>
 #include <linux/i2c.h>
 #include <linux/slab.h>
 #include <linux/string.h>
@@ -32,7 +33,8 @@ static struct i2c_client_address_data addr_data = {
         .forces                 = forces,
 };
 
-#define DAT(x) ((unsigned int)(x->dev.driver_data))
+#define set_ctrl(x, v) i2c_set_clientdata(x, (void *)(unsigned int)(v))
+#define get_ctrl(x)    ((unsigned int)i2c_get_clientdata(x))
 
 static int
 pcf8583_attach(struct i2c_adapter *adap, int addr, int kind)
@@ -40,8 +42,17 @@ pcf8583_attach(struct i2c_adapter *adap, int addr, int kind)
         struct i2c_client *c;
         unsigned char buf[1], ad[1] = { 0 };
         struct i2c_msg msgs[2] = {
-                { addr, 0,        1, ad  },
-                { addr, I2C_M_RD, 1, buf }
+                {
+                        .addr = addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = ad,
+                }, {
+                        .addr = addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = buf,
+                }
         };
 
         c = kmalloc(sizeof(*c), GFP_KERNEL);
@@ -54,7 +65,7 @@ pcf8583_attach(struct i2c_adapter *adap, int addr, int kind)
         c->driver       = &pcf8583_driver;
 
         if (i2c_transfer(c->adapter, msgs, 2) == 2)
-                DAT(c) = buf[0];
+                set_ctrl(c, buf[0]);
 
         return i2c_attach_client(c);
 }
@@ -78,8 +89,17 @@ pcf8583_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
 {
         unsigned char buf[8], addr[1] = { 1 };
         struct i2c_msg msgs[2] = {
-                { client->addr, 0,        1, addr },
-                { client->addr, I2C_M_RD, 6, buf  }
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 6,
+                        .buf = buf,
+                }
         };
         int ret = -EIO;
 
@@ -113,7 +133,7 @@ pcf8583_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
         int ret, len = 6;
 
         buf[0] = 0;
-        buf[1] = DAT(client) | 0x80;
+        buf[1] = get_ctrl(client) | 0x80;
         buf[2] = BIN_TO_BCD(dt->cs);
         buf[3] = BIN_TO_BCD(dt->secs);
         buf[4] = BIN_TO_BCD(dt->mins);
@@ -129,7 +149,7 @@ pcf8583_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
         if (ret == len)
                 ret = 0;
 
-        buf[1] = DAT(client);
+        buf[1] = get_ctrl(client);
         i2c_master_send(client, (char *)buf, 2);
 
         return ret;
@@ -138,7 +158,7 @@ pcf8583_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
 static int
 pcf8583_get_ctrl(struct i2c_client *client, unsigned char *ctrl)
 {
-        *ctrl = DAT(client);
+        *ctrl = get_ctrl(client);
         return 0;
 }
 
@@ -149,7 +169,7 @@ pcf8583_set_ctrl(struct i2c_client *client, unsigned char *ctrl)
 
         buf[0] = 0;
         buf[1] = *ctrl;
-        DAT(client) = *ctrl;
+        set_ctrl(client, *ctrl);
 
         return i2c_master_send(client, (char *)buf, 2);
 }
@@ -159,15 +179,23 @@ pcf8583_read_mem(struct i2c_client *client, struct mem *mem)
 {
         unsigned char addr[1];
         struct i2c_msg msgs[2] = {
-                { client->addr, 0,        1, addr },
-                { client->addr, I2C_M_RD, 0, mem->data }
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = mem->nr,
+                        .buf = mem->data,
+                }
         };
 
         if (mem->loc < 8)
                 return -EINVAL;
 
         addr[0] = mem->loc;
-        msgs[1].len = mem->nr;
 
         return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;
 }
@@ -177,15 +205,23 @@ pcf8583_write_mem(struct i2c_client *client, struct mem *mem)
 {
         unsigned char addr[1];
         struct i2c_msg msgs[2] = {
-                { client->addr, 0, 1, addr },
-                { client->addr, 0, 0, mem->data }
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_NOSTART,
+                        .len = mem->nr,
+                        .buf = mem->data,
+                }
         };
 
         if (mem->loc < 8)
                 return -EINVAL;
 
         addr[0] = mem->loc;
-        msgs[1].len = mem->nr;
 
         return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;
 }
@@ -234,4 +270,14 @@ static __init int pcf8583_init(void)
         return i2c_add_driver(&pcf8583_driver);
 }
 
-__initcall(pcf8583_init);
+static __exit void pcf8583_exit(void)
+{
+        i2c_del_driver(&pcf8583_driver);
+}
+
+module_init(pcf8583_init);
+module_exit(pcf8583_exit);
+
+MODULE_AUTHOR("Russell King");
+MODULE_DESCRIPTION("PCF8583 I2C RTC driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index 01a1bd239263..2143609d2936 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -200,8 +200,7 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
          * Note: Assume that this function returns zero on success
          */
         result = add_memory(mem_device->start_addr,
-                            (mem_device->end_addr - mem_device->start_addr) + 1,
-                            mem_device->read_write_attribute);
+                            (mem_device->end_addr - mem_device->start_addr) + 1);
         if (result) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
                 mem_device->state = MEMORY_INVALID_STATE;
@@ -259,7 +258,7 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
          * Ask the VM to offline this memory range.
          * Note: Assume that this function returns zero on success
          */
-        result = remove_memory(start, len, attr);
+        result = remove_memory(start, len);
         if (result) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));
                 return_VALUE(result);
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 26a3a4016115..161db4acfb91 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -37,6 +37,7 @@
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include <linux/moduleparam.h>
+#include <linux/sched.h>        /* need_resched() */
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index aee50b453265..930427fc0c4b 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -158,7 +158,15 @@ int acpi_suspend(u32 acpi_state)
         return -EINVAL;
 }
 
+static int acpi_pm_state_valid(suspend_state_t pm_state)
+{
+        u32 acpi_state = acpi_suspend_states[pm_state];
+
+        return sleep_states[acpi_state];
+}
+
 static struct pm_ops acpi_pm_ops = {
+        .valid = acpi_pm_state_valid,
         .prepare = acpi_pm_prepare,
         .enter = acpi_pm_enter,
         .finish = acpi_pm_finish,
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 66d9c4643fc1..f12898d53078 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -7,6 +7,7 @@ obj-y			:= core.o sys.o bus.o dd.o \
 obj-y                   += power/
 obj-$(CONFIG_FW_LOADER) += firmware_class.o
 obj-$(CONFIG_NUMA)      += node.o
+obj-$(CONFIG_MEMORY_HOTPLUG) += memory.o
 
 ifeq ($(CONFIG_DEBUG_DRIVER),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/base/class.c b/drivers/base/class.c
index c3e569730afe..db65fd0babe9 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -17,6 +17,7 @@
 #include <linux/string.h>
 #include <linux/kdev_t.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 #include "base.h"
 
 #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 081c927b1ed8..a95844790f7b 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -16,6 +16,8 @@ struct sysdev_class cpu_sysdev_class = {
 };
 EXPORT_SYMBOL(cpu_sysdev_class);
 
+static struct sys_device *cpu_sys_devices[NR_CPUS];
+
 #ifdef CONFIG_HOTPLUG_CPU
 int __attribute__((weak)) smp_prepare_cpu (int cpu)
 {
@@ -64,6 +66,7 @@ static void __devinit register_cpu_control(struct cpu *cpu)
 }
 void unregister_cpu(struct cpu *cpu, struct node *root)
 {
+        int logical_cpu = cpu->sysdev.id;
 
         if (root)
                 sysfs_remove_link(&root->sysdev.kobj,
@@ -71,7 +74,7 @@ void unregister_cpu(struct cpu *cpu, struct node *root)
         sysdev_remove_file(&cpu->sysdev, &attr_online);
 
         sysdev_unregister(&cpu->sysdev);
-
+        cpu_sys_devices[logical_cpu] = NULL;
         return;
 }
 #else /* ... !CONFIG_HOTPLUG_CPU */
@@ -103,10 +106,19 @@ int __devinit register_cpu(struct cpu *cpu, int num, struct node *root)
                                           kobject_name(&cpu->sysdev.kobj));
         if (!error && !cpu->no_control)
                 register_cpu_control(cpu);
+        if (!error)
+                cpu_sys_devices[num] = &cpu->sysdev;
         return error;
 }
 
-
+struct sys_device *get_cpu_sysdev(int cpu)
+{
+        if (cpu < NR_CPUS)
+                return cpu_sys_devices[cpu];
+        else
+                return NULL;
+}
+EXPORT_SYMBOL_GPL(get_cpu_sysdev);
 
 int __init cpu_dev_init(void)
 {
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 4acb2c5733c3..98f6c02d6790 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -62,14 +62,16 @@ firmware_timeout_show(struct class *class, char *buf)
 }
 
 /**
- * firmware_timeout_store:
- * Description:
+ * firmware_timeout_store - set number of seconds to wait for firmware
+ * @class: device class pointer
+ * @buf: buffer to scan for timeout value
+ * @count: number of bytes in @buf
+ *
  *      Sets the number of seconds to wait for the firmware.  Once
- *      this expires an error will be return to the driver and no
+ *      this expires an error will be returned to the driver and no
  *      firmware will be provided.
  *
- *      Note: zero means 'wait for ever'
- *
+ *      Note: zero means 'wait forever'.
  **/
 static ssize_t
 firmware_timeout_store(struct class *class, const char *buf, size_t count)
@@ -123,12 +125,15 @@ firmware_loading_show(struct class_device *class_dev, char *buf)
 }
 
 /**
- * firmware_loading_store: - loading control file
- * Description:
+ * firmware_loading_store - set value in the 'loading' control file
+ * @class_dev: class_device pointer
+ * @buf: buffer to scan for loading control value
+ * @count: number of bytes in @buf
+ *
  *      The relevant values are:
  *
  *       1: Start a load, discarding any previous partial load.
- *       0: Conclude the load and handle the data to the driver code.
+ *       0: Conclude the load and hand the data to the driver code.
  *      -1: Conclude the load with an error and discard any written data.
  **/
 static ssize_t
@@ -201,6 +206,7 @@ out:
         up(&fw_lock);
         return ret_count;
 }
+
 static int
 fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
 {
@@ -227,11 +233,13 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
 }
 
 /**
- * firmware_data_write:
+ * firmware_data_write - write method for firmware
+ * @kobj: kobject for the class_device
+ * @buffer: buffer being written
+ * @offset: buffer offset for write in total data store area
+ * @count: buffer size
  *
- * Description:
- *
- *      Data written to the 'data' attribute will be later handled to
+ *      Data written to the 'data' attribute will be later handed to
  *      the driver as a firmware image.
  **/
 static ssize_t
@@ -264,6 +272,7 @@ out:
         up(&fw_lock);
         return retval;
 }
+
 static struct bin_attribute firmware_attr_data_tmpl = {
         .attr = {.name = "data", .mode = 0644, .owner = THIS_MODULE},
         .size = 0,
@@ -448,13 +457,16 @@ out:
 
 /**
  * request_firmware: - request firmware to hotplug and wait for it
- * Description:
- *      @firmware will be used to return a firmware image by the name
+ * @firmware_p: pointer to firmware image
+ * @name: name of firmware file
+ * @device: device for which firmware is being loaded
+ *
+ *      @firmware_p will be used to return a firmware image by the name
  *      of @name for device @device.
  *
  *      Should be called from user context where sleeping is allowed.
  *
- *      @name will be use as $FIRMWARE in the hotplug environment and
+ *      @name will be used as $FIRMWARE in the hotplug environment and
  *      should be distinctive enough not to be confused with any other
  *      firmware image for this or any other device.
  **/
@@ -468,6 +480,7 @@ request_firmware(const struct firmware **firmware_p, const char *name,
 
 /**
  * release_firmware: - release the resource associated with a firmware image
+ * @fw: firmware resource to release
  **/
 void
 release_firmware(const struct firmware *fw)
@@ -480,8 +493,10 @@ release_firmware(const struct firmware *fw)
 
 /**
  * register_firmware: - provide a firmware image for later usage
+ * @name: name of firmware image file
+ * @data: buffer pointer for the firmware image
+ * @size: size of the data buffer area
  *
- * Description:
  *      Make sure that @data will be available by requesting firmware @name.
  *
  *      Note: This will not be possible until some kind of persistence
@@ -526,21 +541,19 @@ request_firmware_work_func(void *arg)
 }
 
 /**
- * request_firmware_nowait:
+ * request_firmware_nowait: asynchronous version of request_firmware
+ * @module: module requesting the firmware
+ * @hotplug: invokes hotplug event to copy the firmware image if this flag
+ *      is non-zero else the firmware copy must be done manually.
+ * @name: name of firmware file
+ * @device: device for which firmware is being loaded
+ * @context: will be passed over to @cont, and
+ *      @fw may be %NULL if firmware request fails.
+ * @cont: function will be called asynchronously when the firmware
+ *      request is over.
  *
- * Description:
  *      Asynchronous variant of request_firmware() for contexts where
  *      it is not possible to sleep.
- *
- *      @hotplug invokes hotplug event to copy the firmware image if this flag
- *      is non-zero else the firmware copy must be done manually.
- *
- *      @cont will be called asynchronously when the firmware request is over.
- *
- *      @context will be passed over to @cont.
- *
- *      @fw may be %NULL if firmware request fails.
- *
  **/
 int
 request_firmware_nowait(
diff --git a/drivers/base/init.c b/drivers/base/init.c
index 84e604e25c4f..c648914b9cde 100644
--- a/drivers/base/init.c
+++ b/drivers/base/init.c
@@ -9,6 +9,7 @@
 
 #include <linux/device.h>
 #include <linux/init.h>
+#include <linux/memory.h>
 
 #include "base.h"
 
@@ -33,5 +34,6 @@ void __init driver_init(void)
         platform_bus_init();
         system_bus_init();
         cpu_dev_init();
+        memory_dev_init();
         attribute_container_init();
 }
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
new file mode 100644
index 000000000000..b7ddd651d664
--- /dev/null
+++ b/drivers/base/memory.c
@@ -0,0 +1,452 @@
+/*
+ * drivers/base/memory.c - basic Memory class support
+ *
+ * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
+ *            Dave Hansen <haveblue@us.ibm.com>
+ *
+ * This file provides the necessary infrastructure to represent
+ * a SPARSEMEM-memory-model system's physical memory in /sysfs.
+ * All arch-independent code that assumes MEMORY_HOTPLUG requires
+ * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
+ */
+
+#include <linux/sysdev.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>        /* capable() */
+#include <linux/topology.h>
+#include <linux/device.h>
+#include <linux/memory.h>
+#include <linux/kobject.h>
+#include <linux/memory_hotplug.h>
+#include <linux/mm.h>
+#include <asm/atomic.h>
+#include <asm/uaccess.h>
+
+#define MEMORY_CLASS_NAME       "memory"
+
+static struct sysdev_class memory_sysdev_class = {
+        set_kset_name(MEMORY_CLASS_NAME),
+};
+EXPORT_SYMBOL(memory_sysdev_class);
+
+static char *memory_hotplug_name(struct kset *kset, struct kobject *kobj)
+{
+        return MEMORY_CLASS_NAME;
+}
+
+static int memory_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
+                        int num_envp, char *buffer, int buffer_size)
+{
+        int retval = 0;
+
+        return retval;
+}
+
+static struct kset_hotplug_ops memory_hotplug_ops = {
+        .name           = memory_hotplug_name,
+        .hotplug        = memory_hotplug,
+};
+
+static struct notifier_block *memory_chain;
+
+static int register_memory_notifier(struct notifier_block *nb)
+{
+        return notifier_chain_register(&memory_chain, nb);
+}
+
+static void unregister_memory_notifier(struct notifier_block *nb)
+{
+        notifier_chain_unregister(&memory_chain, nb);
+}
+
+/*
+ * register_memory - Setup a sysfs device for a memory block
+ */
+static int
+register_memory(struct memory_block *memory, struct mem_section *section,
+                struct node *root)
+{
+        int error;
+
+        memory->sysdev.cls = &memory_sysdev_class;
+        memory->sysdev.id = __section_nr(section);
+
+        error = sysdev_register(&memory->sysdev);
+
+        if (root && !error)
+                error = sysfs_create_link(&root->sysdev.kobj,
+                                          &memory->sysdev.kobj,
+                                          kobject_name(&memory->sysdev.kobj));
+
+        return error;
+}
+
+static void
+unregister_memory(struct memory_block *memory, struct mem_section *section,
+                struct node *root)
+{
+        BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
+        BUG_ON(memory->sysdev.id != __section_nr(section));
+
+        sysdev_unregister(&memory->sysdev);
+        if (root)
+                sysfs_remove_link(&root->sysdev.kobj,
+                                  kobject_name(&memory->sysdev.kobj));
+}
+
+/*
+ * use this as the physical section index that this memsection
+ * uses.
+ */
+
+static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf)
+{
+        struct memory_block *mem =
+                container_of(dev, struct memory_block, sysdev);
+        return sprintf(buf, "%08lx\n", mem->phys_index);
+}
+
+/*
+ * online, offline, going offline, etc.
+ */
+static ssize_t show_mem_state(struct sys_device *dev, char *buf)
+{
+        struct memory_block *mem =
+                container_of(dev, struct memory_block, sysdev);
+        ssize_t len = 0;
+
+        /*
+         * We can probably put these states in a nice little array
+         * so that they're not open-coded
+         */
+        switch (mem->state) {
+                case MEM_ONLINE:
+                        len = sprintf(buf, "online\n");
+                        break;
+                case MEM_OFFLINE:
+                        len = sprintf(buf, "offline\n");
+                        break;
+                case MEM_GOING_OFFLINE:
+                        len = sprintf(buf, "going-offline\n");
+                        break;
+                default:
+                        len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
+                                        mem->state);
+                        WARN_ON(1);
+                        break;
+        }
+
+        return len;
+}
+
+static inline int memory_notify(unsigned long val, void *v)
+{
+        return notifier_call_chain(&memory_chain, val, v);
+}
+
+/*
+ * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
+ * OK to have direct references to sparsemem variables in here.
+ */
+static int
+memory_block_action(struct memory_block *mem, unsigned long action)
+{
+        int i;
+        unsigned long psection;
+        unsigned long start_pfn, start_paddr;
+        struct page *first_page;
+        int ret;
+        int old_state = mem->state;
+
+        psection = mem->phys_index;
+        first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
+
+        /*
+         * The probe routines leave the pages reserved, just
+         * as the bootmem code does.  Make sure they're still
+         * that way.
+         */
+        if (action == MEM_ONLINE) {
+                for (i = 0; i < PAGES_PER_SECTION; i++) {
+                        if (PageReserved(first_page+i))
+                                continue;
+
+                        printk(KERN_WARNING "section number %ld page number %d "
+                                "not reserved, was it already online? \n",
+                                psection, i);
+                        return -EBUSY;
+                }
+        }
+
+        switch (action) {
+                case MEM_ONLINE:
+                        start_pfn = page_to_pfn(first_page);
+                        ret = online_pages(start_pfn, PAGES_PER_SECTION);
+                        break;
+                case MEM_OFFLINE:
+                        mem->state = MEM_GOING_OFFLINE;
+                        memory_notify(MEM_GOING_OFFLINE, NULL);
+                        start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
+                        ret = remove_memory(start_paddr,
+                                            PAGES_PER_SECTION << PAGE_SHIFT);
+                        if (ret) {
+                                mem->state = old_state;
+                                break;
+                        }
+                        memory_notify(MEM_MAPPING_INVALID, NULL);
+                        break;
+                default:
+                        printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
+                                        __FUNCTION__, mem, action, action);
+                        WARN_ON(1);
+                        ret = -EINVAL;
+        }
+        /*
+         * For now, only notify on successful memory operations
+         */
+        if (!ret)
+                memory_notify(action, NULL);
+
+        return ret;
+}
+
+static int memory_block_change_state(struct memory_block *mem,
+                unsigned long to_state, unsigned long from_state_req)
+{
+        int ret = 0;
+        down(&mem->state_sem);
+
+        if (mem->state != from_state_req) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = memory_block_action(mem, to_state);
+        if (!ret)
+                mem->state = to_state;
+
+out:
+        up(&mem->state_sem);
+        return ret;
+}
+
+static ssize_t
+store_mem_state(struct sys_device *dev, const char *buf, size_t count)
+{
+        struct memory_block *mem;
+        unsigned int phys_section_nr;
+        int ret = -EINVAL;
+
+        mem = container_of(dev, struct memory_block, sysdev);
+        phys_section_nr = mem->phys_index;
+
+        if (!valid_section_nr(phys_section_nr))
+                goto out;
+
+        if (!strncmp(buf, "online", min((int)count, 6)))
+                ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
+        else if(!strncmp(buf, "offline", min((int)count, 7)))
+                ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
+out:
+        if (ret)
+                return ret;
+        return count;
+}
+
+/*
+ * phys_device is a bad name for this.  What I really want
+ * is a way to differentiate between memory ranges that
+ * are part of physical devices that constitute
+ * a complete removable unit or fru.
+ * i.e. do these ranges belong to the same physical device,
+ * s.t. if I offline all of these sections I can then
+ * remove the physical device?
+ */
+static ssize_t show_phys_device(struct sys_device *dev, char *buf)
+{
+        struct memory_block *mem =
+                container_of(dev, struct memory_block, sysdev);
+        return sprintf(buf, "%d\n", mem->phys_device);
+}
+
+static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
+static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
+static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
+
+#define mem_create_simple_file(mem, attr_name)  \
+        sysdev_create_file(&mem->sysdev, &attr_##attr_name)
+#define mem_remove_simple_file(mem, attr_name)  \
+        sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
+
+/*
+ * Block size attribute stuff
+ */
+static ssize_t
+print_block_size(struct class *class, char *buf)
+{
+        return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
+}
+
+static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
+
+static int block_size_init(void)
+{
+        sysfs_create_file(&memory_sysdev_class.kset.kobj,
+                &class_attr_block_size_bytes.attr);
+        return 0;
+}
+
+/*
+ * Some architectures will have custom drivers to do this, and
+ * will not need to do it from userspace.  The fake hot-add code
+ * as well as ppc64 will do all of their discovery in userspace
+ * and will require this interface.
+ */
+#ifdef CONFIG_ARCH_MEMORY_PROBE
+static ssize_t
+memory_probe_store(struct class *class, const char __user *buf, size_t count)
+{
+        u64 phys_addr;
+        int ret;
+
+        phys_addr = simple_strtoull(buf, NULL, 0);
+
+        ret = add_memory(phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
+
+        if (ret)
+                count = ret;
+
+        return count;
+}
+static CLASS_ATTR(probe, 0700, NULL, memory_probe_store);
+
+static int memory_probe_init(void)
+{
+        sysfs_create_file(&memory_sysdev_class.kset.kobj,
+                &class_attr_probe.attr);
+        return 0;
+}
+#else
+#define memory_probe_init(...)  do {} while (0)
+#endif
+
+/*
+ * Note that phys_device is optional.  It is here to allow for
+ * differentiation between which *physical* devices each
+ * section belongs to...
+ */
+
+static int add_memory_block(unsigned long node_id, struct mem_section *section,
+                     unsigned long state, int phys_device)
+{
+        struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
+        int ret = 0;
+
+        if (!mem)
+                return -ENOMEM;
+
+        mem->phys_index = __section_nr(section);
+        mem->state = state;
+        init_MUTEX(&mem->state_sem);
+        mem->phys_device = phys_device;
+
+        ret = register_memory(mem, section, NULL);
+        if (!ret)
+                ret = mem_create_simple_file(mem, phys_index);
+        if (!ret)
+                ret = mem_create_simple_file(mem, state);
+        if (!ret)
+                ret = mem_create_simple_file(mem, phys_device);
+
+        return ret;
+}
+
+/*
+ * For now, we have a linear search to go find the appropriate
+ * memory_block corresponding to a particular phys_index. If
+ * this gets to be a real problem, we can always use a radix
+ * tree or something here.
+ *
+ * This could be made generic for all sysdev classes.
+ */
+static struct memory_block *find_memory_block(struct mem_section *section)
+{
+        struct kobject *kobj;
+        struct sys_device *sysdev;
+        struct memory_block *mem;
+        char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
+
+        /*
+         * This only works because we know that section == sysdev->id
+         * slightly redundant with sysdev_register()
+         */
+        sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
+
+        kobj = kset_find_obj(&memory_sysdev_class.kset, name);
+        if (!kobj)
+                return NULL;
+
+        sysdev = container_of(kobj, struct sys_device, kobj);
+        mem = container_of(sysdev, struct memory_block, sysdev);
+
+        return mem;
+}
+
+int remove_memory_block(unsigned long node_id, struct mem_section *section,
+                int phys_device)
+{
+        struct memory_block *mem;
+
+        mem = find_memory_block(section);
+        mem_remove_simple_file(mem, phys_index);
+        mem_remove_simple_file(mem, state);
+        mem_remove_simple_file(mem, phys_device);
+        unregister_memory(mem, section, NULL);
+
+        return 0;
+}
+
+/*
+ * need an interface for the VM to add new memory regions,
+ * but without onlining it.
+ */
+int register_new_memory(struct mem_section *section)
+{
+        return add_memory_block(0, section, MEM_OFFLINE, 0);
+}
+
+int unregister_memory_section(struct mem_section *section)
+{
+        if (!valid_section(section))
+                return -EINVAL;
+
+        return remove_memory_block(0, section, 0);
+}
+
+/*
+ * Initialize the sysfs support for memory devices...
+ */
+int __init memory_dev_init(void)
+{
+        unsigned int i;
+        int ret;
+
+        memory_sysdev_class.kset.hotplug_ops = &memory_hotplug_ops;
+        ret = sysdev_class_register(&memory_sysdev_class);
+
+        /*
+         * Create entries for memory sections that were found
+         * during boot and have been initialized
+         */
+        for (i = 0; i < NR_MEM_SECTIONS; i++) {
+                if (!valid_section_nr(i))
+                        continue;
+                add_memory_block(0, __nr_to_section(i), MEM_ONLINE, 0);
+        }
+
+        memory_probe_init();
+        block_size_init();
+
+        return ret;
+}
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 95f2af322c8f..d597c922af11 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -16,6 +16,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/bootmem.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include "base.h"
 
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 3431eb6004c3..66ed8f2fece5 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/pm.h>
+#include <asm/semaphore.h>
 
 extern struct subsystem devices_subsys;
 
diff --git a/drivers/block/Kconfig.iosched b/drivers/block/Kconfig.iosched
index 6070a480600b..5b90d2fa63b8 100644
--- a/drivers/block/Kconfig.iosched
+++ b/drivers/block/Kconfig.iosched
@@ -38,4 +38,32 @@ config IOSCHED_CFQ
           among all processes in the system. It should provide a fair
           working environment, suitable for desktop systems.
 
+choice
+        prompt "Default I/O scheduler"
+        default DEFAULT_AS
+        help
+          Select the I/O scheduler which will be used by default for all
+          block devices.
+
+        config DEFAULT_AS
+                bool "Anticipatory" if IOSCHED_AS
+
+        config DEFAULT_DEADLINE
+                bool "Deadline" if IOSCHED_DEADLINE
+
+        config DEFAULT_CFQ
+                bool "CFQ" if IOSCHED_CFQ
+
+        config DEFAULT_NOOP
+                bool "No-op"
+
+endchoice
+
+config DEFAULT_IOSCHED
+        string
+        default "anticipatory" if DEFAULT_AS
+        default "deadline" if DEFAULT_DEADLINE
+        default "cfq" if DEFAULT_CFQ
+        default "noop" if DEFAULT_NOOP
+
 endmenu
diff --git a/drivers/block/as-iosched.c b/drivers/block/as-iosched.c
index 4081c36c8c19..c6744ff38294 100644
--- a/drivers/block/as-iosched.c
+++ b/drivers/block/as-iosched.c
@@ -1344,6 +1344,7 @@ as_add_aliased_request(struct as_data *ad, struct as_rq *arq, struct as_rq *alia
          * Don't want to have to handle merges.
          */
         as_del_arq_hash(arq);
+        arq->request->flags |= REQ_NOMERGE;
 }
 
 /*
@@ -1972,8 +1973,8 @@ static int __init as_init(void)
 
 static void __exit as_exit(void)
 {
-        kmem_cache_destroy(arq_pool);
         elv_unregister(&iosched_as);
+        kmem_cache_destroy(arq_pool);
 }
 
 module_init(as_init);
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index e183a3ef7839..ec27976a57da 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -28,13 +28,17 @@
    through the array controller.  Note in particular, neither 
    physical nor logical disks are presented through the scsi layer. */
 
+#include <linux/timer.h>
+#include <linux/completion.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+
+#include <asm/atomic.h>
+
 #include <scsi/scsi.h> 
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h> 
-#include <asm/atomic.h>
-#include <linux/timer.h>
-#include <linux/completion.h>
 
 #include "cciss_scsi.h"
 
diff --git a/drivers/block/cfq-iosched.c b/drivers/block/cfq-iosched.c
index 94690e4d41e0..5281f8e70510 100644
--- a/drivers/block/cfq-iosched.c
+++ b/drivers/block/cfq-iosched.c
@@ -2418,28 +2418,8 @@ static int __init cfq_init(void)
 
 static void __exit cfq_exit(void)
 {
-        struct task_struct *g, *p;
-        unsigned long flags;
-
-        read_lock_irqsave(&tasklist_lock, flags);
-
-        /*
-         * iterate each process in the system, removing our io_context
-         */
-        do_each_thread(g, p) {
-                struct io_context *ioc = p->io_context;
-
-                if (ioc && ioc->cic) {
-                        ioc->cic->exit(ioc->cic);
-                        cfq_free_io_context(ioc->cic);
-                        ioc->cic = NULL;
-                }
-        } while_each_thread(g, p);
-
-        read_unlock_irqrestore(&tasklist_lock, flags);
-
-        cfq_slab_kill();
         elv_unregister(&iosched_cfq);
+        cfq_slab_kill();
 }
 
 module_init(cfq_init);
diff --git a/drivers/block/elevator.c b/drivers/block/elevator.c
index 55621d5c5774..36f1057084b0 100644
--- a/drivers/block/elevator.c
+++ b/drivers/block/elevator.c
@@ -147,24 +147,17 @@ static void elevator_setup_default(void)
         struct elevator_type *e;
 
         /*
-         * check if default is set and exists
+         * If default has not been set, use the compiled-in selection.
          */
-        if (chosen_elevator[0] && (e = elevator_get(chosen_elevator))) {
-                elevator_put(e);
-                return;
-        }
+        if (!chosen_elevator[0])
+                strcpy(chosen_elevator, CONFIG_DEFAULT_IOSCHED);
 
-#if defined(CONFIG_IOSCHED_AS)
-        strcpy(chosen_elevator, "anticipatory");
-#elif defined(CONFIG_IOSCHED_DEADLINE)
-        strcpy(chosen_elevator, "deadline");
-#elif defined(CONFIG_IOSCHED_CFQ)
-        strcpy(chosen_elevator, "cfq");
-#elif defined(CONFIG_IOSCHED_NOOP)
-        strcpy(chosen_elevator, "noop");
-#else
-#error "You must build at least 1 IO scheduler into the kernel"
-#endif
+        /*
+         * If the given scheduler is not available, fall back to no-op.
+         */
+        if (!(e = elevator_find(chosen_elevator)))
+                strcpy(chosen_elevator, "noop");
+        elevator_put(e);
 }
 
 static int __init elevator_setup(char *str)
@@ -642,6 +635,27 @@ EXPORT_SYMBOL_GPL(elv_register);
 
 void elv_unregister(struct elevator_type *e)
 {
+        struct task_struct *g, *p;
+
+        /*
+         * Iterate every thread in the process to remove the io contexts.
+         */
+        read_lock(&tasklist_lock);
+        do_each_thread(g, p) {
+                struct io_context *ioc = p->io_context;
+                if (ioc && ioc->cic) {
+                        ioc->cic->exit(ioc->cic);
+                        ioc->cic->dtor(ioc->cic);
+                        ioc->cic = NULL;
+                }
+                if (ioc && ioc->aic) {
+                        ioc->aic->exit(ioc->aic);
+                        ioc->aic->dtor(ioc->aic);
+                        ioc->aic = NULL;
+                }
+        } while_each_thread(g, p);
+        read_unlock(&tasklist_lock);
+
         spin_lock_irq(&elv_list_lock);
         list_del_init(&e->list);
         spin_unlock_irq(&elv_list_lock);
@@ -739,8 +753,10 @@ ssize_t elv_iosched_store(request_queue_t *q, const char *name, size_t count)
                 return -EINVAL;
         }
 
-        if (!strcmp(elevator_name, q->elevator->elevator_type->elevator_name))
+        if (!strcmp(elevator_name, q->elevator->elevator_type->elevator_name)) {
+                elevator_put(e);
                 return count;
+        }
 
         elevator_switch(q, e);
         return count;
diff --git a/drivers/block/paride/paride.c b/drivers/block/paride/paride.c
index 1fef136c0e41..ce94aa11f6a7 100644
--- a/drivers/block/paride/paride.c
+++ b/drivers/block/paride/paride.c
@@ -29,6 +29,7 @@
 #include <linux/string.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
+#include <linux/sched.h>        /* TASK_* */
 
 #ifdef CONFIG_PARPORT_MODULE
 #define CONFIG_PARPORT
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 94af920465b5..e9746af29b9f 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -807,10 +807,6 @@ static int pf_next_buf(void)
                 return 1;
         spin_lock_irqsave(&pf_spin_lock, saved_flags);
         pf_end_request(1);
-        if (pf_req) {
-                pf_count = pf_req->current_nr_sectors;
-                pf_buf = pf_req->buffer;
-        }
         spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
         return 1;
 }
diff --git a/drivers/block/paride/pg.c b/drivers/block/paride/pg.c
index 82f2d6d2eeef..6f5df0fad703 100644
--- a/drivers/block/paride/pg.c
+++ b/drivers/block/paride/pg.c
@@ -162,6 +162,8 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
 #include <linux/mtio.h>
 #include <linux/pg.h>
 #include <linux/device.h>
+#include <linux/sched.h>        /* current, TASK_* */
+#include <linux/jiffies.h>
 
 #include <asm/uaccess.h>
 
diff --git a/drivers/block/paride/pt.c b/drivers/block/paride/pt.c
index 686c95573452..715ae5dc88fb 100644
--- a/drivers/block/paride/pt.c
+++ b/drivers/block/paride/pt.c
@@ -146,6 +146,7 @@ static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
 #include <linux/slab.h>
 #include <linux/mtio.h>
 #include <linux/device.h>
+#include <linux/sched.h>        /* current, TASK_*, schedule_timeout() */
 
 #include <asm/uaccess.h>
 
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index e46ecd23b3ac..709f809f79f1 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -778,13 +778,16 @@ static struct vio_device_id viodasd_device_table[] __devinitdata = {
         { "viodasd", "" },
         { "", "" }
 };
-
 MODULE_DEVICE_TABLE(vio, viodasd_device_table);
+
 static struct vio_driver viodasd_driver = {
-        .name = "viodasd",
         .id_table = viodasd_device_table,
         .probe = viodasd_probe,
-        .remove = viodasd_remove
+        .remove = viodasd_remove,
+        .driver = {
+                .name = "viodasd",
+                .owner = THIS_MODULE,
+        }
 };
 
 /*
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 0829db58462f..36f31d202223 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -736,13 +736,16 @@ static struct vio_device_id viocd_device_table[] __devinitdata = {
         { "viocd", "" },
         { "", "" }
 };
-
 MODULE_DEVICE_TABLE(vio, viocd_device_table);
+
 static struct vio_driver viocd_driver = {
-        .name = "viocd",
         .id_table = viocd_device_table,
         .probe = viocd_probe,
-        .remove = viocd_remove
+        .remove = viocd_remove,
+        .driver = {
+                .name = "viocd",
+                .owner = THIS_MODULE,
+        }
 };
 
 static int __init viocd_init(void)
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index c29365d5b524..fdf4370db994 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -661,7 +661,7 @@ config HW_RANDOM
 
 config NVRAM
         tristate "/dev/nvram support"
-        depends on ATARI || X86 || X86_64 || ARM || GENERIC_NVRAM
+        depends on ATARI || X86 || ARM || GENERIC_NVRAM
         ---help---
           If you say Y here and create a character special file /dev/nvram
           with major number 10 and minor number 144 using mknod ("man mknod"),
@@ -985,7 +985,7 @@ config MAX_RAW_DEVS
 
 config HANGCHECK_TIMER
         tristate "Hangcheck timer"
-        depends on X86_64 || X86 || IA64 || PPC64 || ARCH_S390
+        depends on X86 || IA64 || PPC64 || ARCH_S390
         help
           The hangcheck-timer module detects when the system has gone
           out to lunch past a certain margin.  It can reboot the system
@@ -1001,5 +1001,17 @@ config MMTIMER
 
 source "drivers/char/tpm/Kconfig"
 
+config TELCLOCK
+        tristate "Telecom clock driver for MPBL0010 ATCA SBC"
+        depends on EXPERIMENTAL
+        default n
+        help
+          The telecom clock device is specific to the MPBL0010 ATCA computer and
+          allows direct userspace access to the configuration of the telecom clock
+          configuration settings.  This device is used for hardware synchronization
+          across the ATCA backplane fabric.  Upon loading, the driver exports a
+          sysfs directory, /sys/devices/platform/telco_clock, with a number of
+          files for controlling the behavior of this hardware.
+
 endmenu
 
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 08f69287ea36..4aeae687e88a 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -82,6 +82,7 @@ obj-$(CONFIG_NWFLASH) += nwflash.o
 obj-$(CONFIG_SCx200_GPIO) += scx200_gpio.o
 obj-$(CONFIG_GPIO_VR41XX) += vr41xx_giu.o
 obj-$(CONFIG_TANBAC_TB0219) += tb0219.o
+obj-$(CONFIG_TELCLOCK) += tlclk.o
 
 obj-$(CONFIG_WATCHDOG)  += watchdog/
 obj-$(CONFIG_MWAVE) += mwave/
diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 7f8c1b53b754..486ed8a11b59 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -27,7 +27,7 @@ config AGP
 
 config AGP_ALI
         tristate "ALI chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         ---help---
           This option gives you AGP support for the GLX component of
           XFree86 4.x on the following ALi chipsets.  The supported chipsets
@@ -45,7 +45,7 @@ config AGP_ALI
 
 config AGP_ATI
         tristate "ATI chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         ---help---
       This option gives you AGP support for the GLX component of
       XFree86 4.x on the ATI RadeonIGP family of chipsets.
@@ -55,7 +55,7 @@ config AGP_ATI
 
 config AGP_AMD
         tristate "AMD Irongate, 761, and 762 chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on AMD Irongate, 761, and 762 chipsets.
@@ -91,7 +91,7 @@ config AGP_INTEL
 
 config AGP_NVIDIA
         tristate "NVIDIA nForce/nForce2 chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on the following NVIDIA chipsets.  The supported chipsets
@@ -99,7 +99,7 @@ config AGP_NVIDIA
 
 config AGP_SIS
         tristate "SiS chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on Silicon Integrated Systems [SiS] chipsets.
@@ -111,14 +111,14 @@ config AGP_SIS
 
 config AGP_SWORKS
         tristate "Serverworks LE/HE chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           Say Y here to support the Serverworks AGP card.  See 
           <http://www.serverworks.com/> for product descriptions and images.
 
 config AGP_VIA
         tristate "VIA chipset support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
           XFree86 4.x on VIA MVP3/Apollo Pro chipsets.
@@ -154,7 +154,7 @@ config AGP_UNINORTH
 
 config AGP_EFFICEON
         tristate "Transmeta Efficeon support"
-        depends on AGP && X86 && !X86_64
+        depends on AGP && X86_32
         help
           This option gives you AGP support for the Transmeta Efficeon
           series processors with integrated northbridges.
diff --git a/drivers/char/agp/ali-agp.c b/drivers/char/agp/ali-agp.c
index 9c9c9c2247ce..b02fc2267159 100644
--- a/drivers/char/agp/ali-agp.c
+++ b/drivers/char/agp/ali-agp.c
@@ -7,6 +7,7 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/agp_backend.h>
+#include <asm/page.h>           /* PAGE_SIZE */
 #include "agp.h"
 
 #define ALI_AGPCTRL     0xb8
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 0a7624a9b1c1..0e6c3a31d344 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -13,6 +13,7 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/agp_backend.h>
+#include <asm/page.h>           /* PAGE_SIZE */
 #include "agp.h"
 
 /* Will need to be increased if AMD64 ever goes >8-way. */
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index e572ced9100a..0b6e72642d6e 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -6,6 +6,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/agp_backend.h>
 #include <asm/agp.h>
 #include "agp.h"
diff --git a/drivers/char/agp/i460-agp.c b/drivers/char/agp/i460-agp.c
index 94943298c03e..a2d9e5e48bbe 100644
--- a/drivers/char/agp/i460-agp.c
+++ b/drivers/char/agp/i460-agp.c
@@ -10,6 +10,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/agp_backend.h>
 
 #include "agp.h"
diff --git a/drivers/char/agp/isoch.c b/drivers/char/agp/isoch.c
index c9ac731504f2..40083241804e 100644
--- a/drivers/char/agp/isoch.c
+++ b/drivers/char/agp/isoch.c
@@ -6,6 +6,7 @@
 #include <linux/pci.h>
 #include <linux/agp_backend.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include "agp.h"
 
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index a9fb12c20eb7..71ea59a1dbeb 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -5,6 +5,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/agp_backend.h>
 #include "agp.h"
 
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index cf4c3648463d..c7f818cd7b02 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -281,7 +281,7 @@ static char rcsid[] =
  * make sure "cyc" appears in all kernel messages; all soft interrupts
  * handled by same routine; recognize out-of-band reception; comment
  * out some diagnostic messages; leave RTS/CTS flow control to hardware;
- * fix race condition in -Z buffer management; only -Y needs to explictly
+ * fix race condition in -Z buffer management; only -Y needs to explicitly
  * flush chars; tidy up some startup messages;
  *
  * Revision 1.36.4.18  1996/07/25 18:57:31  bentson
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 475cc5e555e1..6d3449761914 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -15,6 +15,8 @@
 #include <linux/device.h>
 #include <linux/kdev_t.h>
 #include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/string.h>
 
 #include "drm_core.h"
 #include "drmP.h"
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 407708a001e4..b7a0e4d6b934 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -3113,6 +3113,7 @@ MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
 int __init init_PCI (void)
 {       /* Begin init_PCI */
         memset (&epca_driver, 0, sizeof (epca_driver));
+        epca_driver.owner = THIS_MODULE;
         epca_driver.name = "epca";
         epca_driver.id_table = epca_pci_tbl;
         epca_driver.probe = epca_init_one;
diff --git a/drivers/char/hangcheck-timer.c b/drivers/char/hangcheck-timer.c
index a54bc93353af..66e53dd450ff 100644
--- a/drivers/char/hangcheck-timer.c
+++ b/drivers/char/hangcheck-timer.c
@@ -117,7 +117,7 @@ __setup("hcheck_reboot", hangcheck_parse_reboot);
 __setup("hcheck_dump_tasks", hangcheck_parse_dump_tasks);
 #endif /* not MODULE */
 
-#if defined(CONFIG_X86) || defined(CONFIG_X86_64)
+#if defined(CONFIG_X86)
 # define HAVE_MONOTONIC
 # define TIMER_FREQ 1000000000ULL
 #elif defined(CONFIG_ARCH_S390)
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index c055bb630ffc..3808d9572619 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -49,7 +49,9 @@
 #define HPET_USER_FREQ  (64)
 #define HPET_DRIFT      (500)
 
-static u32 hpet_ntimer, hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
+#define HPET_RANGE_SIZE         1024    /* from HPET spec */
+
+static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
 
 /* A lock for concurrent access by app and isr hpet activity. */
 static DEFINE_SPINLOCK(hpet_lock);
@@ -78,7 +80,7 @@ struct hpets {
         struct hpet __iomem *hp_hpet;
         unsigned long hp_hpet_phys;
         struct time_interpolator *hp_interpolator;
-        unsigned long hp_period;
+        unsigned long long hp_tick_freq;
         unsigned long hp_delta;
         unsigned int hp_ntimer;
         unsigned int hp_which;
@@ -90,6 +92,7 @@ static struct hpets *hpets;
 #define HPET_OPEN               0x0001
 #define HPET_IE                 0x0002  /* interrupt enabled */
 #define HPET_PERIODIC           0x0004
+#define HPET_SHARED_IRQ         0x0008
 
 #if BITS_PER_LONG == 64
 #define write_counter(V, MC)    writeq(V, MC)
@@ -120,6 +123,11 @@ static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs)
         unsigned long isr;
 
         devp = data;
+        isr = 1 << (devp - devp->hd_hpets->hp_dev);
+
+        if ((devp->hd_flags & HPET_SHARED_IRQ) &&
+            !(isr & readl(&devp->hd_hpet->hpet_isr)))
+                return IRQ_NONE;
 
         spin_lock(&hpet_lock);
         devp->hd_irqdata++;
@@ -137,8 +145,8 @@ static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs)
                               &devp->hd_timer->hpet_compare);
         }
 
-        isr = (1 << (devp - devp->hd_hpets->hp_dev));
-        writeq(isr, &devp->hd_hpet->hpet_isr);
+        if (devp->hd_flags & HPET_SHARED_IRQ)
+                writel(isr, &devp->hd_hpet->hpet_isr);
         spin_unlock(&hpet_lock);
 
         spin_lock(&hpet_task_lock);
@@ -276,7 +284,8 @@ static int hpet_mmap(struct file *file, struct vm_area_struct *vma)
 
         if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
                                         PAGE_SIZE, vma->vm_page_prot)) {
-                printk(KERN_ERR "remap_pfn_range failed in hpet.c\n");
+                printk(KERN_ERR "%s: io_remap_pfn_range failed\n",
+                        __FUNCTION__);
                 return -EAGAIN;
         }
 
@@ -364,7 +373,9 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
         hpet = devp->hd_hpet;
         hpetp = devp->hd_hpets;
 
-        v = readq(&timer->hpet_config);
+        if (!devp->hd_ireqfreq)
+                return -EIO;
+
         spin_lock_irq(&hpet_lock);
 
         if (devp->hd_flags & HPET_IE) {
@@ -373,16 +384,21 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
         }
 
         devp->hd_flags |= HPET_IE;
+
+        if (readl(&timer->hpet_config) & Tn_INT_TYPE_CNF_MASK)
+                devp->hd_flags |= HPET_SHARED_IRQ;
         spin_unlock_irq(&hpet_lock);
 
-        t = readq(&timer->hpet_config);
         irq = devp->hd_hdwirq;
 
         if (irq) {
-                sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev));
+                unsigned long irq_flags;
 
-                if (request_irq
-                    (irq, hpet_interrupt, SA_INTERRUPT, devp->hd_name, (void *)devp)) {
+                sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev));
+                irq_flags = devp->hd_flags & HPET_SHARED_IRQ
+                                                ? SA_SHIRQ : SA_INTERRUPT;
+                if (request_irq(irq, hpet_interrupt, irq_flags,
+                                devp->hd_name, (void *)devp)) {
                         printk(KERN_ERR "hpet: IRQ %d is not free\n", irq);
                         irq = 0;
                 }
@@ -416,20 +432,24 @@ static int hpet_ioctl_ieon(struct hpet_dev *devp)
                 write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
         }
 
-        isr = (1 << (devp - hpets->hp_dev));
-        writeq(isr, &hpet->hpet_isr);
+        if (devp->hd_flags & HPET_SHARED_IRQ) {
+                isr = 1 << (devp - devp->hd_hpets->hp_dev);
+                writel(isr, &hpet->hpet_isr);
+        }
         writeq(g, &timer->hpet_config);
         local_irq_restore(flags);
 
         return 0;
 }
 
-static inline unsigned long hpet_time_div(unsigned long dis)
+/* converts Hz to number of timer ticks */
+static inline unsigned long hpet_time_div(struct hpets *hpets,
+                                          unsigned long dis)
 {
-        unsigned long long m = 1000000000000000ULL;
+        unsigned long long m;
 
+        m = hpets->hp_tick_freq + (dis >> 1);
         do_div(m, dis);
-
         return (unsigned long)m;
 }
 
@@ -477,14 +497,21 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                 {
                         struct hpet_info info;
 
-                        info.hi_ireqfreq = hpet_time_div(hpetp->hp_period *
-                                                         devp->hd_ireqfreq);
+                        if (devp->hd_ireqfreq)
+                                info.hi_ireqfreq =
+                                        hpet_time_div(hpetp, devp->hd_ireqfreq);
+                        else
+                                info.hi_ireqfreq = 0;
                         info.hi_flags =
                             readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK;
-                        info.hi_hpet = devp->hd_hpets->hp_which;
-                        info.hi_timer = devp - devp->hd_hpets->hp_dev;
-                        if (copy_to_user((void __user *)arg, &info, sizeof(info)))
-                                err = -EFAULT;
+                        info.hi_hpet = hpetp->hp_which;
+                        info.hi_timer = devp - hpetp->hp_dev;
+                        if (kernel)
+                                memcpy((void *)arg, &info, sizeof(info));
+                        else
+                                if (copy_to_user((void __user *)arg, &info,
+                                                 sizeof(info)))
+                                        err = -EFAULT;
                         break;
                 }
         case HPET_EPI:
@@ -516,12 +543,12 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                         break;
                 }
 
-                if (arg & (arg - 1)) {
+                if (!arg) {
                         err = -EINVAL;
                         break;
                 }
 
-                devp->hd_ireqfreq = hpet_time_div(hpetp->hp_period * arg);
+                devp->hd_ireqfreq = hpet_time_div(hpetp, arg);
         }
 
         return err;
@@ -539,6 +566,17 @@ static struct file_operations hpet_fops = {
         .mmap = hpet_mmap,
 };
 
+static int hpet_is_known(struct hpet_data *hdp)
+{
+        struct hpets *hpetp;
+
+        for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
+                if (hpetp->hp_hpet_phys == hdp->hd_phys_address)
+                        return 1;
+
+        return 0;
+}
+
 EXPORT_SYMBOL(hpet_alloc);
 EXPORT_SYMBOL(hpet_register);
 EXPORT_SYMBOL(hpet_unregister);
@@ -563,6 +601,8 @@ int hpet_register(struct hpet_task *tp, int periodic)
                 return -EINVAL;
         }
 
+        tp->ht_opaque = NULL;
+
         spin_lock_irq(&hpet_task_lock);
         spin_lock(&hpet_lock);
 
@@ -702,15 +742,14 @@ static void hpet_register_interpolator(struct hpets *hpetp)
 #ifdef  CONFIG_TIME_INTERPOLATION
         struct time_interpolator *ti;
 
-        ti = kmalloc(sizeof(*ti), GFP_KERNEL);
+        ti = kzalloc(sizeof(*ti), GFP_KERNEL);
         if (!ti)
                 return;
 
-        memset(ti, 0, sizeof(*ti));
         ti->source = TIME_SOURCE_MMIO64;
         ti->shift = 10;
         ti->addr = &hpetp->hp_hpet->hpet_mc;
-        ti->frequency = hpet_time_div(hpets->hp_period);
+        ti->frequency = hpetp->hp_tick_freq;
         ti->drift = HPET_DRIFT;
         ti->mask = -1;
 
@@ -743,11 +782,11 @@ static unsigned long hpet_calibrate(struct hpets *hpetp)
         if (!timer)
                 return 0;
 
-        hpet = hpets->hp_hpet;
+        hpet = hpetp->hp_hpet;
         t = read_counter(&timer->hpet_compare);
 
         i = 0;
-        count = hpet_time_div(hpetp->hp_period * TICK_CALIBRATE);
+        count = hpet_time_div(hpetp, TICK_CALIBRATE);
 
         local_irq_save(flags);
 
@@ -771,28 +810,29 @@ int hpet_alloc(struct hpet_data *hdp)
         struct hpets *hpetp;
         size_t siz;
         struct hpet __iomem *hpet;
-        static struct hpets *last = (struct hpets *)0;
-        unsigned long ns;
+        static struct hpets *last = NULL;
+        unsigned long period;
+        unsigned long long temp;
 
         /*
          * hpet_alloc can be called by platform dependent code.
-         * if platform dependent code has allocated the hpet
-         * ACPI also reports hpet, then we catch it here.
+         * If platform dependent code has allocated the hpet that
+         * ACPI has also reported, then we catch it here.
          */
-        for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-                if (hpetp->hp_hpet == hdp->hd_address)
-                        return 0;
+        if (hpet_is_known(hdp)) {
+                printk(KERN_DEBUG "%s: duplicate HPET ignored\n",
+                        __FUNCTION__);
+                return 0;
+        }
 
         siz = sizeof(struct hpets) + ((hdp->hd_nirqs - 1) *
                                       sizeof(struct hpet_dev));
 
-        hpetp = kmalloc(siz, GFP_KERNEL);
+        hpetp = kzalloc(siz, GFP_KERNEL);
 
         if (!hpetp)
                 return -ENOMEM;
 
-        memset(hpetp, 0, siz);
-
         hpetp->hp_which = hpet_nhpet++;
         hpetp->hp_hpet = hdp->hd_address;
         hpetp->hp_hpet_phys = hdp->hd_phys_address;
@@ -822,21 +862,23 @@ int hpet_alloc(struct hpet_data *hdp)
 
         last = hpetp;
 
-        hpetp->hp_period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
-            HPET_COUNTER_CLK_PERIOD_SHIFT;
+        period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
+                HPET_COUNTER_CLK_PERIOD_SHIFT; /* fs, 10^-15 */
+        temp = 1000000000000000uLL; /* 10^15 femtoseconds per second */
+        temp += period >> 1; /* round */
+        do_div(temp, period);
+        hpetp->hp_tick_freq = temp; /* ticks per second */
 
-        printk(KERN_INFO "hpet%d: at MMIO 0x%lx, IRQ%s",
-                hpetp->hp_which, hdp->hd_phys_address,
+        printk(KERN_INFO "hpet%d: at MMIO 0x%lx (virtual 0x%p), IRQ%s",
+                hpetp->hp_which, hdp->hd_phys_address, hdp->hd_address,
                 hpetp->hp_ntimer > 1 ? "s" : "");
         for (i = 0; i < hpetp->hp_ntimer; i++)
                 printk("%s %d", i > 0 ? "," : "", hdp->hd_irq[i]);
         printk("\n");
 
-        ns = hpetp->hp_period;  /* femptoseconds, 10^-15 */
-        ns /= 1000000;          /* convert to nanoseconds, 10^-9 */
-        printk(KERN_INFO "hpet%d: %ldns tick, %d %d-bit timers\n",
-                hpetp->hp_which, ns, hpetp->hp_ntimer,
-                cap & HPET_COUNTER_SIZE_MASK ? 64 : 32);
+        printk(KERN_INFO "hpet%u: %u %d-bit timers, %Lu Hz\n",
+               hpetp->hp_which, hpetp->hp_ntimer,
+               cap & HPET_COUNTER_SIZE_MASK ? 64 : 32, hpetp->hp_tick_freq);
 
         mcfg = readq(&hpet->hpet_config);
         if ((mcfg & HPET_ENABLE_CNF_MASK) == 0) {
@@ -845,13 +887,10 @@ int hpet_alloc(struct hpet_data *hdp)
                 writeq(mcfg, &hpet->hpet_config);
         }
 
-        for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer;
-             i++, hpet_ntimer++, devp++) {
-                unsigned long v;
+        for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer; i++, devp++) {
                 struct hpet_timer __iomem *timer;
 
                 timer = &hpet->hpet_timers[devp - hpetp->hp_dev];
-                v = readq(&timer->hpet_config);
 
                 devp->hd_hpets = hpetp;
                 devp->hd_hpet = hpet;
@@ -880,7 +919,6 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
         struct hpet_data *hdp;
         acpi_status status;
         struct acpi_resource_address64 addr;
-        struct hpets *hpetp;
 
         hdp = data;
 
@@ -893,9 +931,29 @@ static acpi_status hpet_resources(struct acpi_resource *res, void *data)
                 hdp->hd_phys_address = addr.min_address_range;
                 hdp->hd_address = ioremap(addr.min_address_range, size);
 
-                for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-                        if (hpetp->hp_hpet == hdp->hd_address)
-                                return -EBUSY;
+                if (hpet_is_known(hdp)) {
+                        printk(KERN_DEBUG "%s: 0x%lx is busy\n",
+                                __FUNCTION__, hdp->hd_phys_address);
+                        iounmap(hdp->hd_address);
+                        return -EBUSY;
+                }
+        } else if (res->id == ACPI_RSTYPE_FIXED_MEM32) {
+                struct acpi_resource_fixed_mem32 *fixmem32;
+
+                fixmem32 = &res->data.fixed_memory32;
+                if (!fixmem32)
+                        return -EINVAL;
+
+                hdp->hd_phys_address = fixmem32->range_base_address;
+                hdp->hd_address = ioremap(fixmem32->range_base_address,
+                                                HPET_RANGE_SIZE);
+
+                if (hpet_is_known(hdp)) {
+                        printk(KERN_DEBUG "%s: 0x%lx is busy\n",
+                                __FUNCTION__, hdp->hd_phys_address);
+                        iounmap(hdp->hd_address);
+                        return -EBUSY;
+                }
         } else if (res->id == ACPI_RSTYPE_EXT_IRQ) {
                 struct acpi_resource_ext_irq *irqp;
                 int i;
diff --git a/drivers/char/hvc_vio.c b/drivers/char/hvc_vio.c
index 78d681dc35a8..f5212eb2b41d 100644
--- a/drivers/char/hvc_vio.c
+++ b/drivers/char/hvc_vio.c
@@ -95,11 +95,11 @@ static int __devexit hvc_vio_remove(struct vio_dev *vdev)
 }
 
 static struct vio_driver hvc_vio_driver = {
-        .name           = hvc_driver_name,
         .id_table       = hvc_driver_table,
         .probe          = hvc_vio_probe,
         .remove         = hvc_vio_remove,
         .driver         = {
+                .name   = hvc_driver_name,
                 .owner  = THIS_MODULE,
         }
 };
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index f47f009f9259..53dc77c760fc 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -720,10 +720,13 @@ static int __devexit hvcs_remove(struct vio_dev *dev)
 };
 
 static struct vio_driver hvcs_vio_driver = {
-        .name           = hvcs_driver_name,
         .id_table       = hvcs_driver_table,
         .probe          = hvcs_probe,
         .remove         = hvcs_remove,
+        .driver         = {
+                .name   = hvcs_driver_name,
+                .owner  = THIS_MODULE,
+        }
 };
 
 /* Only called from hvcs_get_pi please */
diff --git a/drivers/char/lcd.c b/drivers/char/lcd.c
index b77161146144..29963d8be667 100644
--- a/drivers/char/lcd.c
+++ b/drivers/char/lcd.c
@@ -575,8 +575,8 @@ static inline int button_pressed(void)
 
 static int lcd_waiters = 0;
 
-static long lcd_read(struct inode *inode, struct file *file, char *buf,
-                     unsigned long count)
+static ssize_t lcd_read(struct file *file, char *buf,
+                     size_t count, loff_t *ofs)
 {
         long buttons_now;
 
diff --git a/drivers/char/lcd.h b/drivers/char/lcd.h
index 878a95280e87..a8d4ae737158 100644
--- a/drivers/char/lcd.h
+++ b/drivers/char/lcd.h
@@ -22,7 +22,7 @@ static int timeout(volatile unsigned long);
 #define MAX_IDLE_TIME 120
 
 struct lcd_display {
-        unsigned long buttons;
+        unsigned buttons;
         int size1;
         int size2;
         unsigned char line1[LCD_CHARS_PER_LINE];
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 38be4b0dbd1c..91dd669273e0 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -231,9 +231,7 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
 static int mmap_mem(struct file * file, struct vm_area_struct * vma)
 {
 #if defined(__HAVE_PHYS_MEM_ACCESS_PROT)
-        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
-
-        vma->vm_page_prot = phys_mem_access_prot(file, offset,
+        vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
                                                  vma->vm_end - vma->vm_start,
                                                  vma->vm_page_prot);
 #elif defined(pgprot_noncached)
diff --git a/drivers/char/mwave/3780i.c b/drivers/char/mwave/3780i.c
index 613aed9e1840..d1fe05e83882 100644
--- a/drivers/char/mwave/3780i.c
+++ b/drivers/char/mwave/3780i.c
@@ -53,6 +53,8 @@
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/sched.h>        /* cond_resched() */
+
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/drivers/char/qtronix.c b/drivers/char/qtronix.c
index 40a3cf62e1a8..601d09baf9d7 100644
--- a/drivers/char/qtronix.c
+++ b/drivers/char/qtronix.c
@@ -591,6 +591,11 @@ static int __init psaux_init(void)
                 return retval;
 
         queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
+        if (!queue) {
+                misc_deregister(&psaux_mouse);
+                return -ENOMEM;
+        }
+                
         memset(queue, 0, sizeof(*queue));
         queue->head = queue->tail = 0;
         init_waitqueue_head(&queue->proc_list);
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 5b1d3680c8ab..928b850cc679 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -256,7 +256,6 @@ static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
 static int sReadAiopID(ByteIO_t io);
 static int sReadAiopNumChan(WordIO_t io);
 
-#ifdef MODULE
 MODULE_AUTHOR("Theodore Ts'o");
 MODULE_DESCRIPTION("Comtrol RocketPort driver");
 module_param(board1, ulong, 0);
@@ -288,17 +287,14 @@ MODULE_PARM_DESC(pc104_3, "set interface types for ISA(PC104) board #3 (e.g. pc1
 module_param_array(pc104_4, ulong, NULL, 0);
 MODULE_PARM_DESC(pc104_4, "set interface types for ISA(PC104) board #4 (e.g. pc104_4=232,232,485,485,...");
 
-int rp_init(void);
+static int rp_init(void);
 static void rp_cleanup_module(void);
 
 module_init(rp_init);
 module_exit(rp_cleanup_module);
 
-#endif
 
-#ifdef MODULE_LICENSE
 MODULE_LICENSE("Dual BSD/GPL");
-#endif
 
 /*************************************************************************/
 /*                     Module code starts here                           */
@@ -2378,7 +2374,7 @@ static struct tty_operations rocket_ops = {
 /*
  * The module "startup" routine; it's run when the module is loaded.
  */
-int __init rp_init(void)
+static int __init rp_init(void)
 {
         int retval, pci_boards_found, isa_boards_found, i;
 
@@ -2502,7 +2498,6 @@ int __init rp_init(void)
         return 0;
 }
 
-#ifdef MODULE
 
 static void rp_cleanup_module(void)
 {
@@ -2530,7 +2525,6 @@ static void rp_cleanup_module(void)
         if (controller)
                 release_region(controller, 4);
 }
-#endif
 
 /***************************************************************************
 Function: sInitController
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 6b4e9d155f50..dda30e42ec79 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -790,7 +790,7 @@ static int __init a2232board_init(void)
 
         }       
 
-        printk("Total: %d A2232 boards initialized.\n.", nr_a2232); /* Some status report if no card was found */
+        printk("Total: %d A2232 boards initialized.\n", nr_a2232); /* Some status report if no card was found */
 
         a2232_init_portstructs();
 
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index 50e0b612a8a2..352547eabf7b 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -38,19 +38,19 @@
  *
  * Revision 1.0:  April 1st 1997.
  *                Initial release for alpha testing.
- * Revision 1.1:  April 14th 1997. 
- *                Incorporated Richard Hudsons suggestions, 
+ * Revision 1.1:  April 14th 1997.
+ *                Incorporated Richard Hudsons suggestions,
  *                removed some debugging printk's.
  * Revision 1.2:  April 15th 1997.
  *                Ported to 2.1.x kernels.
- * Revision 1.3:  April 17th 1997 
- *                Backported to 2.0. (Compatibility macros). 
+ * Revision 1.3:  April 17th 1997
+ *                Backported to 2.0. (Compatibility macros).
  * Revision 1.4:  April 18th 1997
- *                Fixed DTR/RTS bug that caused the card to indicate 
- *                "don't send data" to a modem after the password prompt.  
+ *                Fixed DTR/RTS bug that caused the card to indicate
+ *                "don't send data" to a modem after the password prompt.
  *                Fixed bug for premature (fake) interrupts.
  * Revision 1.5:  April 19th 1997
- *                fixed a minor typo in the header file, cleanup a little. 
+ *                fixed a minor typo in the header file, cleanup a little.
  *                performance warnings are now MAXed at once per minute.
  * Revision 1.6:  May 23 1997
  *                Changed the specialix=... format to include interrupt.
@@ -60,10 +60,10 @@
  *                port to linux-2.1.43 kernel.
  * Revision 1.9:  Oct 9  1998
  *                Added stuff for the IO8+/PCI version.
- * Revision 1.10: Oct 22  1999 / Jan 21 2000. 
- *                Added stuff for setserial. 
+ * Revision 1.10: Oct 22  1999 / Jan 21 2000.
+ *                Added stuff for setserial.
  *                Nicolas Mailhot (Nicolas.Mailhot@email.enst.fr)
- * 
+ *
  */
 
 #define VERSION "1.11"
@@ -154,7 +154,7 @@ static int sx_poll = HZ;
 
 
 
-/* 
+/*
  * The following defines are mostly for testing purposes. But if you need
  * some nice reporting in your syslog, you can define them also.
  */
@@ -188,7 +188,7 @@ static DECLARE_MUTEX(tmp_buf_sem);
 
 static unsigned long baud_table[] =  {
         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
-        9600, 19200, 38400, 57600, 115200, 0, 
+        9600, 19200, 38400, 57600, 115200, 0,
 };
 
 static struct specialix_board sx_board[SX_NBOARD] =  {
@@ -216,7 +216,7 @@ static inline int sx_paranoia_check(struct specialix_port const * port,
                 KERN_ERR "sx: Warning: bad specialix port magic number for device %s in %s\n";
         static const char *badinfo =
                 KERN_ERR "sx: Warning: null specialix port for device %s in %s\n";
- 
+
         if (!port) {
                 printk(badinfo, name, routine);
                 return 1;
@@ -231,9 +231,9 @@ static inline int sx_paranoia_check(struct specialix_port const * port,
 
 
 /*
- * 
+ *
  *  Service functions for specialix IO8+ driver.
- * 
+ *
  */
 
 /* Get board number from pointer */
@@ -246,7 +246,7 @@ static inline int board_No (struct specialix_board * bp)
 /* Get port number from pointer */
 static inline int port_No (struct specialix_port const * port)
 {
-        return SX_PORT(port - sx_port); 
+        return SX_PORT(port - sx_port);
 }
 
 
@@ -309,7 +309,7 @@ static inline void sx_wait_CCR(struct specialix_board  * bp)
                         return;
                 udelay (1);
         }
-        
+
         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 }
 
@@ -329,7 +329,7 @@ static inline void sx_wait_CCR_off(struct specialix_board  * bp)
                         return;
                 udelay (1);
         }
-        
+
         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 }
 
@@ -338,34 +338,28 @@ static inline void sx_wait_CCR_off(struct specialix_board  * bp)
  *  specialix IO8+ IO range functions.
  */
 
-static inline int sx_check_io_range(struct specialix_board * bp)
+static inline int sx_request_io_range(struct specialix_board * bp)
 {
-        return check_region (bp->base, SX_IO_SPACE);
-}
-
-
-static inline void sx_request_io_range(struct specialix_board * bp)
-{
-        request_region(bp->base, 
-                       bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE,
-                       "specialix IO8+" );
+        return request_region(bp->base,
+                bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
+                "specialix IO8+") == NULL;
 }
 
 
 static inline void sx_release_io_range(struct specialix_board * bp)
 {
-        release_region(bp->base, 
+        release_region(bp->base,
                        bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE);
 }
 
-        
+
 /* Must be called with enabled interrupts */
-/* Ugly. Very ugly. Don't use this for anything else than initialization 
+/* Ugly. Very ugly. Don't use this for anything else than initialization
    code */
 static inline void sx_long_delay(unsigned long delay)
 {
         unsigned long i;
-        
+
         for (i = jiffies + delay; time_after(i, jiffies); ) ;
 }
 
@@ -378,7 +372,7 @@ static int sx_set_irq ( struct specialix_board *bp)
         int i;
         unsigned long flags;
 
-        if (bp->flags & SX_BOARD_IS_PCI) 
+        if (bp->flags & SX_BOARD_IS_PCI)
                 return 1;
         switch (bp->irq) {
         /* In the same order as in the docs... */
@@ -420,7 +414,7 @@ static int sx_init_CD186x(struct specialix_board  * bp)
         sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT);      /* Prio for receiver intr    */
         /* Set RegAckEn */
         sx_out_off(bp, CD186x_SRCR, sx_in (bp, CD186x_SRCR) | SRCR_REGACKEN);
-        
+
         /* Setting up prescaler. We need 4 ticks per 1 ms */
         scaler =  SX_OSCFREQ/SPECIALIX_TPS;
 
@@ -448,7 +442,7 @@ static int read_cross_byte (struct specialix_board *bp, int reg, int bit)
         spin_lock_irqsave(&bp->lock, flags);
         for (i=0, t=0;i<8;i++) {
                 sx_out_off (bp, CD186x_CAR, i);
-                if (sx_in_off (bp, reg) & bit) 
+                if (sx_in_off (bp, reg) & bit)
                         t |= 1 << i;
         }
         spin_unlock_irqrestore(&bp->lock, flags);
@@ -472,7 +466,7 @@ void missed_irq (unsigned long data)
         spin_unlock_irqrestore(&bp->lock, flags);
         if (irq) {
                 printk (KERN_INFO "Missed interrupt... Calling int from timer. \n");
-                sx_interrupt (((struct specialix_board *)data)->irq, 
+                sx_interrupt (((struct specialix_board *)data)->irq,
                               (void*)data, NULL);
         }
         missed_irq_timer.expires = jiffies + sx_poll;
@@ -495,7 +489,7 @@ static int sx_probe(struct specialix_board *bp)
 
         func_enter();
 
-        if (sx_check_io_range(bp)) {
+        if (sx_request_io_range(bp)) {
                 func_exit();
                 return 1;
         }
@@ -509,15 +503,16 @@ static int sx_probe(struct specialix_board *bp)
         short_pause ();
         val2 = sx_in_off(bp, CD186x_PPRL);
 
-        
+
         if ((val1 != 0x5a) || (val2 != 0xa5)) {
                 printk(KERN_INFO "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
                        board_No(bp), bp->base);
+                sx_release_io_range(bp);
                 func_exit();
                 return 1;
         }
 
-        /* Check the DSR lines that Specialix uses as board 
+        /* Check the DSR lines that Specialix uses as board
            identification */
         val1 = read_cross_byte (bp, CD186x_MSVR, MSVR_DSR);
         val2 = read_cross_byte (bp, CD186x_MSVR, MSVR_RTS);
@@ -532,6 +527,7 @@ static int sx_probe(struct specialix_board *bp)
         if (val1 != val2) {
                 printk(KERN_INFO "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
                        board_No(bp), val2, bp->base, val1);
+                sx_release_io_range(bp);
                 func_exit();
                 return 1;
         }
@@ -546,7 +542,7 @@ static int sx_probe(struct specialix_board *bp)
                 sx_wait_CCR(bp);
                 sx_out(bp, CD186x_CCR, CCR_TXEN);        /* Enable transmitter     */
                 sx_out(bp, CD186x_IER, IER_TXRDY);       /* Enable tx empty intr   */
-                sx_long_delay(HZ/20);                   
+                sx_long_delay(HZ/20);
                 irqs = probe_irq_off(irqs);
 
                 dprintk (SX_DEBUG_INIT, "SRSR = %02x, ", sx_in(bp, CD186x_SRSR));
@@ -561,14 +557,15 @@ static int sx_probe(struct specialix_board *bp)
                 }
 
                 dprintk (SX_DEBUG_INIT "val1 = %02x, val2 = %02x, val3 = %02x.\n",
-                        val1, val2, val3); 
-        
+                        val1, val2, val3);
+
         }
-        
+
 #if 0
         if (irqs <= 0) {
                 printk(KERN_ERR "sx%d: Can't find IRQ for specialix IO8+ board at 0x%03x.\n",
                        board_No(bp), bp->base);
+                sx_release_io_range(bp);
                 func_exit();
                 return 1;
         }
@@ -579,19 +576,20 @@ static int sx_probe(struct specialix_board *bp)
 #endif
         /* Reset CD186x again  */
         if (!sx_init_CD186x(bp)) {
+                sx_release_io_range(bp);
                 func_exit();
-                return -EIO;
+                return 1;
         }
 
         sx_request_io_range(bp);
         bp->flags |= SX_BOARD_PRESENT;
-        
+
         /* Chip           revcode   pkgtype
                           GFRCR     SRCR bit 7
            CD180 rev B    0x81      0
            CD180 rev C    0x82      0
            CD1864 rev A   0x82      1
-           CD1865 rev A   0x83      1  -- Do not use!!! Does not work. 
+           CD1865 rev A   0x83      1  -- Do not use!!! Does not work.
            CD1865 rev B   0x84      1
          -- Thanks to Gwen Wang, Cirrus Logic.
          */
@@ -623,8 +621,8 @@ static int sx_probe(struct specialix_board *bp)
         return 0;
 }
 
-/* 
- * 
+/*
+ *
  *  Interrupt processing routines.
  * */
 
@@ -657,7 +655,7 @@ static inline struct specialix_port * sx_get_port(struct specialix_board * bp,
                         return port;
                 }
         }
-        printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n", 
+        printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
                board_No(bp), what, channel);
         return NULL;
 }
@@ -681,7 +679,7 @@ static inline void sx_receive_exc(struct specialix_board * bp)
         tty = port->tty;
         dprintk (SX_DEBUG_RX, "port: %p count: %d BUFF_SIZE: %d\n",
                  port,  tty->flip.count, TTY_FLIPBUF_SIZE);
-        
+
         status = sx_in(bp, CD186x_RCSR);
 
         dprintk (SX_DEBUG_RX, "status: 0x%x\n", status);
@@ -707,30 +705,30 @@ static inline void sx_receive_exc(struct specialix_board * bp)
                 return;
         }
         if (status & RCSR_TOUT) {
-                printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?\n", 
+                printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
                        board_No(bp), port_No(port));
                 func_exit();
                 return;
-                
+
         } else if (status & RCSR_BREAK) {
                 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
                        board_No(bp), port_No(port));
                 *tty->flip.flag_buf_ptr++ = TTY_BREAK;
                 if (port->flags & ASYNC_SAK)
                         do_SAK(tty);
-                
-        } else if (status & RCSR_PE) 
+
+        } else if (status & RCSR_PE)
                 *tty->flip.flag_buf_ptr++ = TTY_PARITY;
-        
-        else if (status & RCSR_FE) 
+
+        else if (status & RCSR_FE)
                 *tty->flip.flag_buf_ptr++ = TTY_FRAME;
-        
+
         else if (status & RCSR_OE)
                 *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
-        
+
         else
                 *tty->flip.flag_buf_ptr++ = 0;
-        
+
         *tty->flip.char_buf_ptr++ = ch;
         tty->flip.count++;
         schedule_delayed_work(&tty->flip.work, 1);
@@ -746,18 +744,18 @@ static inline void sx_receive(struct specialix_board * bp)
         unsigned char count;
 
         func_enter();
-        
+
         if (!(port = sx_get_port(bp, "Receive"))) {
                 dprintk (SX_DEBUG_RX, "Hmm, couldn't find port.\n");
                 func_exit();
                 return;
         }
         tty = port->tty;
-        
+
         count = sx_in(bp, CD186x_RDCR);
         dprintk (SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
         port->hits[count > 8 ? 9 : count]++;
-        
+
         while (count--) {
                 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
                         printk(KERN_INFO "sx%d: port %d: Working around flip buffer overflow.\n",
@@ -787,7 +785,7 @@ static inline void sx_transmit(struct specialix_board * bp)
         }
         dprintk (SX_DEBUG_TX, "port: %p\n", port);
         tty = port->tty;
-        
+
         if (port->IER & IER_TXEMPTY) {
                 /* FIFO drained */
                 sx_out(bp, CD186x_CAR, port_No(port));
@@ -796,7 +794,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 func_exit();
                 return;
         }
-        
+
         if ((port->xmit_cnt <= 0 && !port->break_length)
             || tty->stopped || tty->hw_stopped) {
                 sx_out(bp, CD186x_CAR, port_No(port));
@@ -805,7 +803,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 func_exit();
                 return;
         }
-        
+
         if (port->break_length) {
                 if (port->break_length > 0) {
                         if (port->COR2 & COR2_ETC) {
@@ -831,7 +829,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 func_exit();
                 return;
         }
-        
+
         count = CD186x_NFIFO;
         do {
                 sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
@@ -839,7 +837,7 @@ static inline void sx_transmit(struct specialix_board * bp)
                 if (--port->xmit_cnt <= 0)
                         break;
         } while (--count > 0);
-        
+
         if (port->xmit_cnt <= 0) {
                 sx_out(bp, CD186x_CAR, port_No(port));
                 port->IER &= ~IER_TXRDY;
@@ -862,9 +860,9 @@ static inline void sx_check_modem(struct specialix_board * bp)
         dprintk (SX_DEBUG_SIGNALS, "Modem intr. ");
         if (!(port = sx_get_port(bp, "Modem")))
                 return;
-        
+
         tty = port->tty;
-        
+
         mcr = sx_in(bp, CD186x_MCR);
         printk ("mcr = %02x.\n", mcr);
 
@@ -879,7 +877,7 @@ static inline void sx_check_modem(struct specialix_board * bp)
                         schedule_work(&port->tqueue_hangup);
                 }
         }
-        
+
 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
         if (mcr & MCR_CTSCHG) {
                 if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
@@ -906,7 +904,7 @@ static inline void sx_check_modem(struct specialix_board * bp)
                 sx_out(bp, CD186x_IER, port->IER);
         }
 #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
-        
+
         /* Clear change bits */
         sx_out(bp, CD186x_MCR, 0);
 }
@@ -940,7 +938,7 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         while ((++loop < 16) && (status = (sx_in(bp, CD186x_SRSR) &
                                            (SRSR_RREQint |
                                             SRSR_TREQint |
-                                            SRSR_MREQint)))) {  
+                                            SRSR_MREQint)))) {
                 if (status & SRSR_RREQint) {
                         ack = sx_in(bp, CD186x_RRAR);
 
@@ -951,7 +949,7 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                         else
                                 printk(KERN_ERR "sx%d: status: 0x%x Bad receive ack 0x%02x.\n",
                                        board_No(bp), status, ack);
-                
+
                 } else if (status & SRSR_TREQint) {
                         ack = sx_in(bp, CD186x_TRAR);
 
@@ -963,13 +961,13 @@ static irqreturn_t sx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 } else if (status & SRSR_MREQint) {
                         ack = sx_in(bp, CD186x_MRAR);
 
-                        if (ack == (SX_ID | GIVR_IT_MODEM)) 
+                        if (ack == (SX_ID | GIVR_IT_MODEM))
                                 sx_check_modem(bp);
                         else
                                 printk(KERN_ERR "sx%d: status: 0x%x Bad modem ack 0x%02x.\n",
                                        board_No(bp), status, ack);
-                
-                } 
+
+                }
 
                 sx_out(bp, CD186x_EOIR, 0);   /* Mark end of interrupt */
         }
@@ -1026,7 +1024,7 @@ static inline int sx_setup_board(struct specialix_board * bp)
 {
         int error;
 
-        if (bp->flags & SX_BOARD_ACTIVE) 
+        if (bp->flags & SX_BOARD_ACTIVE)
                 return 0;
 
         if (bp->flags & SX_BOARD_IS_PCI)
@@ -1034,7 +1032,7 @@ static inline int sx_setup_board(struct specialix_board * bp)
         else
                 error = request_irq(bp->irq, sx_interrupt, SA_INTERRUPT, "specialix IO8+", bp);
 
-        if (error) 
+        if (error)
                 return error;
 
         turn_ints_on (bp);
@@ -1055,7 +1053,7 @@ static inline void sx_shutdown_board(struct specialix_board *bp)
         }
 
         bp->flags &= ~SX_BOARD_ACTIVE;
-        
+
         dprintk (SX_DEBUG_IRQ, "Freeing IRQ%d for board %d.\n",
                  bp->irq, board_No (bp));
         free_irq(bp->irq, bp);
@@ -1068,7 +1066,7 @@ static inline void sx_shutdown_board(struct specialix_board *bp)
 
 
 /*
- * Setting up port characteristics. 
+ * Setting up port characteristics.
  * Must be called with disabled interrupts
  */
 static void sx_change_speed(struct specialix_board *bp, struct specialix_port *port)
@@ -1103,10 +1101,10 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
         spin_unlock_irqrestore(&bp->lock, flags);
         dprintk (SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
         baud = C_BAUD(tty);
-        
+
         if (baud & CBAUDEX) {
                 baud &= ~CBAUDEX;
-                if (baud < 1 || baud > 2) 
+                if (baud < 1 || baud > 2)
                         port->tty->termios->c_cflag &= ~CBAUDEX;
                 else
                         baud += 15;
@@ -1117,8 +1115,8 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
                         baud += 2;
         }
-        
-        
+
+
         if (!baud_table[baud]) {
                 /* Drop DTR & exit */
                 dprintk (SX_DEBUG_TERMIOS, "Dropping DTR...  Hmm....\n");
@@ -1127,7 +1125,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                         spin_lock_irqsave(&bp->lock, flags);
                         sx_out(bp, CD186x_MSVR, port->MSVR );
                         spin_unlock_irqrestore(&bp->lock, flags);
-                } 
+                }
                 else
                         dprintk (SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
                 return;
@@ -1137,9 +1135,9 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                         port ->MSVR |= MSVR_DTR;
                 }
         }
-        
+
         /*
-         * Now we must calculate some speed depended things 
+         * Now we must calculate some speed depended things
          */
 
         /* Set baud rate for port */
@@ -1152,7 +1150,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 tmp = (((SX_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
                          CD186x_TPC/2) / CD186x_TPC);
 
-        if ((tmp < 0x10) && time_before(again, jiffies)) { 
+        if ((tmp < 0x10) && time_before(again, jiffies)) {
                 again = jiffies + HZ * 60;
                 /* Page 48 of version 2.0 of the CL-CD1865 databook */
                 if (tmp >= 12) {
@@ -1164,27 +1162,27 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                         printk (KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
                                 "Warning: overstressing Cirrus chip. "
                                 "This might not work.\n"
-                                "Read specialix.txt for more info.\n", 
+                                "Read specialix.txt for more info.\n",
                                 port_No (port), tmp);
                 }
         }
         spin_lock_irqsave(&bp->lock, flags);
-        sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff); 
-        sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff); 
-        sx_out(bp, CD186x_RBPRL, tmp & 0xff); 
+        sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
+        sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
+        sx_out(bp, CD186x_RBPRL, tmp & 0xff);
         sx_out(bp, CD186x_TBPRL, tmp & 0xff);
         spin_unlock_irqrestore(&bp->lock, flags);
         if (port->custom_divisor) {
                 baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
                 baud = ( baud + 5 ) / 10;
-        } else 
+        } else
                 baud = (baud_table[baud] + 5) / 10;   /* Estimated CPS */
 
         /* Two timer ticks seems enough to wakeup something like SLIP driver */
-        tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;          
+        tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
         port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
                                               SERIAL_XMIT_SIZE - 1 : tmp);
-        
+
         /* Receiver timeout will be transmission time for 1.5 chars */
         tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
         tmp = (tmp > 0xff) ? 0xff : tmp;
@@ -1205,29 +1203,29 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 cor1 |= COR1_8BITS;
                 break;
         }
-        
-        if (C_CSTOPB(tty)) 
+
+        if (C_CSTOPB(tty))
                 cor1 |= COR1_2SB;
-        
+
         cor1 |= COR1_IGNORE;
         if (C_PARENB(tty)) {
                 cor1 |= COR1_NORMPAR;
-                if (C_PARODD(tty)) 
+                if (C_PARODD(tty))
                         cor1 |= COR1_ODDP;
-                if (I_INPCK(tty)) 
+                if (I_INPCK(tty))
                         cor1 &= ~COR1_IGNORE;
         }
         /* Set marking of some errors */
         port->mark_mask = RCSR_OE | RCSR_TOUT;
-        if (I_INPCK(tty)) 
+        if (I_INPCK(tty))
                 port->mark_mask |= RCSR_FE | RCSR_PE;
-        if (I_BRKINT(tty) || I_PARMRK(tty)) 
+        if (I_BRKINT(tty) || I_PARMRK(tty))
                 port->mark_mask |= RCSR_BREAK;
-        if (I_IGNPAR(tty)) 
+        if (I_IGNPAR(tty))
                 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
         if (I_IGNBRK(tty)) {
                 port->mark_mask &= ~RCSR_BREAK;
-                if (I_IGNPAR(tty)) 
+                if (I_IGNPAR(tty))
                         /* Real raw mode. Ignore all */
                         port->mark_mask &= ~RCSR_OE;
         }
@@ -1241,7 +1239,7 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) & (MSVR_CTS|MSVR_DSR));
                 spin_unlock_irqrestore(&bp->lock, flags);
 #else
-                port->COR2 |= COR2_CTSAE; 
+                port->COR2 |= COR2_CTSAE;
 #endif
         }
         /* Enable Software Flow Control. FIXME: I'm not sure about this */
@@ -1264,11 +1262,11 @@ static void sx_change_speed(struct specialix_board *bp, struct specialix_port *p
                 mcor1 |= MCOR1_CDZD;
                 mcor2 |= MCOR2_CDOD;
         }
-        
-        if (C_CREAD(tty)) 
+
+        if (C_CREAD(tty))
                 /* Enable receiver */
                 port->IER |= IER_RXD;
-        
+
         /* Set input FIFO size (1-8 bytes) */
         cor3 |= sx_rxfifo;
         /* Setting up CD186x channel registers */
@@ -1311,11 +1309,11 @@ static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port
                 func_exit();
                 return 0;
         }
-        
+
         if (!port->xmit_buf) {
                 /* We may sleep in get_zeroed_page() */
                 unsigned long tmp;
-                
+
                 if (!(tmp = get_zeroed_page(GFP_KERNEL))) {
                         func_exit();
                         return -ENOMEM;
@@ -1328,10 +1326,10 @@ static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port
                 }
                 port->xmit_buf = (unsigned char *) tmp;
         }
-                
+
         spin_lock_irqsave(&port->lock, flags);
 
-        if (port->tty) 
+        if (port->tty)
                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
 
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
@@ -1340,7 +1338,7 @@ static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port
 
         spin_unlock_irqrestore(&port->lock, flags);
 
-                
+
         func_exit();
         return 0;
 }
@@ -1352,14 +1350,14 @@ static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *
         struct tty_struct *tty;
         int i;
         unsigned long flags;
-        
+
         func_enter();
 
         if (!(port->flags & ASYNC_INITIALIZED)) {
                 func_exit();
                 return;
         }
-        
+
         if (sx_debug & SX_DEBUG_FIFO) {
                 dprintk(SX_DEBUG_FIFO, "sx%d: port %d: %ld overruns, FIFO hits [ ",
                         board_No(bp), port_No(port), port->overrun);
@@ -1394,13 +1392,13 @@ static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *
         if (tty)
                 set_bit(TTY_IO_ERROR, &tty->flags);
         port->flags &= ~ASYNC_INITIALIZED;
-        
-        if (!bp->count) 
+
+        if (!bp->count)
                 sx_shutdown_board(bp);
         func_exit();
 }
 
-        
+
 static int block_til_ready(struct tty_struct *tty, struct file * filp,
                            struct specialix_port *port)
 {
@@ -1427,7 +1425,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
                         return -ERESTARTSYS;
                 }
         }
-        
+
         /*
          * If non-blocking mode is set, or the port is not enabled,
          * then make the check up front and then exit.
@@ -1477,7 +1475,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
                         if (port->flags & ASYNC_HUP_NOTIFY)
                                 retval = -EAGAIN;
                         else
-                                retval = -ERESTARTSYS;  
+                                retval = -ERESTARTSYS;
                         break;
                 }
                 if (!(port->flags & ASYNC_CLOSING) &&
@@ -1506,7 +1504,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
         port->flags |= ASYNC_NORMAL_ACTIVE;
         func_exit();
         return 0;
-}       
+}
 
 
 static int sx_open(struct tty_struct * tty, struct file * filp)
@@ -1526,7 +1524,7 @@ static int sx_open(struct tty_struct * tty, struct file * filp)
                 func_exit();
                 return -ENODEV;
         }
-        
+
         bp = &sx_board[board];
         port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
         port->overrun = 0;
@@ -1557,7 +1555,7 @@ static int sx_open(struct tty_struct * tty, struct file * filp)
                 func_enter();
                 return error;
         }
-        
+
         if ((error = block_til_ready(tty, filp, port))) {
                 func_enter();
                 return error;
@@ -1574,7 +1572,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
         struct specialix_board *bp;
         unsigned long flags;
         unsigned long timeout;
-        
+
         func_enter();
         if (!port || sx_paranoia_check(port, tty->name, "close")) {
                 func_exit();
@@ -1587,7 +1585,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
         if ((tty->count == 1) && (port->count != 1)) {
                 printk(KERN_ERR "sx%d: sx_close: bad port count;"
@@ -1607,7 +1605,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
         }
         port->flags |= ASYNC_CLOSING;
         /*
-         * Now we wait for the transmit buffer to clear; and we notify 
+         * Now we wait for the transmit buffer to clear; and we notify
          * the line discipline to only process XON/XOFF characters.
          */
         tty->closing = 1;
@@ -1681,7 +1679,7 @@ static void sx_close(struct tty_struct * tty, struct file * filp)
 }
 
 
-static int sx_write(struct tty_struct * tty, 
+static int sx_write(struct tty_struct * tty,
                     const unsigned char *buf, int count)
 {
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
@@ -1694,7 +1692,7 @@ static int sx_write(struct tty_struct * tty,
                 func_exit();
                 return 0;
         }
-        
+
         bp = port_Board(port);
 
         if (!tty || !port->xmit_buf || !tmp_buf) {
@@ -1824,7 +1822,7 @@ static int sx_chars_in_buffer(struct tty_struct *tty)
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
 
         func_enter();
-        
+
         if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
                 func_exit();
                 return 0;
@@ -1881,13 +1879,13 @@ static int sx_tiocmget(struct tty_struct *tty, struct file *file)
                 port_No(port), status, sx_in (bp, CD186x_CAR));
         dprintk (SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
         if (SX_CRTSCTS(port->tty)) {
-                result  = /*   (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */ 
+                result  = /*   (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */
                           |   ((status & MSVR_DTR) ? TIOCM_RTS : 0)
                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
                           |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
                           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
         } else {
-                result  = /*   (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */ 
+                result  = /*   (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */
                           |   ((status & MSVR_DTR) ? TIOCM_DTR : 0)
                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
                           |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
@@ -1955,7 +1953,7 @@ static inline void sx_send_break(struct specialix_port * port, unsigned long len
 {
         struct specialix_board *bp = port_Board(port);
         unsigned long flags;
-        
+
         func_enter();
 
         spin_lock_irqsave (&port->lock, flags);
@@ -1996,8 +1994,8 @@ static inline int sx_set_serial_info(struct specialix_port * port,
                 func_enter();
                 return -EFAULT;
         }
-        
-#if 0   
+
+#if 0
         if ((tmp.irq != bp->irq) ||
             (tmp.port != bp->base) ||
             (tmp.type != PORT_CIRRUS) ||
@@ -2008,12 +2006,12 @@ static inline int sx_set_serial_info(struct specialix_port * port,
                 func_exit();
                 return -EINVAL;
         }
-#endif  
+#endif
 
         change_speed = ((port->flags & ASYNC_SPD_MASK) !=
                         (tmp.flags & ASYNC_SPD_MASK));
         change_speed |= (tmp.custom_divisor != port->custom_divisor);
-        
+
         if (!capable(CAP_SYS_ADMIN)) {
                 if ((tmp.close_delay != port->close_delay) ||
                     (tmp.closing_wait != port->closing_wait) ||
@@ -2045,7 +2043,7 @@ static inline int sx_get_serial_info(struct specialix_port * port,
 {
         struct serial_struct tmp;
         struct specialix_board *bp = port_Board(port);
-        
+
         func_enter();
 
         /*
@@ -2074,7 +2072,7 @@ static inline int sx_get_serial_info(struct specialix_port * port,
 }
 
 
-static int sx_ioctl(struct tty_struct * tty, struct file * filp, 
+static int sx_ioctl(struct tty_struct * tty, struct file * filp,
                     unsigned int cmd, unsigned long arg)
 {
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
@@ -2087,7 +2085,7 @@ static int sx_ioctl(struct tty_struct * tty, struct file * filp,
                 func_exit();
                 return -ENODEV;
         }
-        
+
         switch (cmd) {
          case TCSBRK:   /* SVID version: non-zero arg --> no break */
                 retval = tty_check_change(tty);
@@ -2129,7 +2127,7 @@ static int sx_ioctl(struct tty_struct * tty, struct file * filp,
          case TIOCGSERIAL:
                  func_exit();
                 return sx_get_serial_info(port, argp);
-         case TIOCSSERIAL:      
+         case TIOCSSERIAL:
                  func_exit();
                 return sx_set_serial_info(port, argp);
          default:
@@ -2153,16 +2151,16 @@ static void sx_throttle(struct tty_struct * tty)
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         /* Use DTR instead of RTS ! */
-        if (SX_CRTSCTS (tty)) 
+        if (SX_CRTSCTS (tty))
                 port->MSVR &= ~MSVR_DTR;
         else {
                 /* Auch!!! I think the system shouldn't call this then. */
                 /* Or maybe we're supposed (allowed?) to do our side of hw
-                   handshake anyway, even when hardware handshake is off. 
+                   handshake anyway, even when hardware handshake is off.
                    When you see this in your logs, please report.... */
                 printk (KERN_ERR "sx%d: Need to throttle, but can't (hardware hs is off)\n",
                          port_No (port));
@@ -2193,14 +2191,14 @@ static void sx_unthrottle(struct tty_struct * tty)
         unsigned long flags;
 
         func_enter();
-                                
+
         if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         spin_lock_irqsave(&port->lock, flags);
         /* XXXX Use DTR INSTEAD???? */
         if (SX_CRTSCTS(tty)) {
@@ -2234,14 +2232,14 @@ static void sx_stop(struct tty_struct * tty)
         unsigned long flags;
 
         func_enter();
-        
+
         if (sx_paranoia_check(port, tty->name, "sx_stop")) {
                 func_exit();
                 return;
         }
 
         bp = port_Board(port);
-        
+
         spin_lock_irqsave(&port->lock, flags);
         port->IER &= ~IER_TXRDY;
         spin_lock_irqsave(&bp->lock, flags);
@@ -2261,14 +2259,14 @@ static void sx_start(struct tty_struct * tty)
         unsigned long flags;
 
         func_enter();
-                                
+
         if (sx_paranoia_check(port, tty->name, "sx_start")) {
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         spin_lock_irqsave(&port->lock, flags);
         if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
                 port->IER |= IER_TXRDY;
@@ -2290,13 +2288,13 @@ static void sx_start(struct tty_struct * tty)
  *
  *      serial interrupt routine -> (workqueue) ->
  *      do_sx_hangup() -> tty->hangup() -> sx_hangup()
- * 
+ *
  */
 static void do_sx_hangup(void *private_)
 {
         struct specialix_port   *port = (struct specialix_port *) private_;
         struct tty_struct       *tty;
-        
+
         func_enter();
 
         tty = port->tty;
@@ -2319,9 +2317,9 @@ static void sx_hangup(struct tty_struct * tty)
                 func_exit();
                 return;
         }
-        
+
         bp = port_Board(port);
-        
+
         sx_shutdown_port(bp, port);
         spin_lock_irqsave(&port->lock, flags);
         port->event = 0;
@@ -2346,10 +2344,10 @@ static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios
         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
         unsigned long flags;
         struct specialix_board  * bp;
-                                
+
         if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
                 return;
-        
+
         if (tty->termios->c_cflag == old_termios->c_cflag &&
             tty->termios->c_iflag == old_termios->c_iflag)
                 return;
@@ -2420,7 +2418,7 @@ static int sx_init_drivers(void)
                 func_exit();
                 return 1;
         }
-        
+
         if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
                 printk(KERN_ERR "sx: Couldn't get free page.\n");
                 put_tty_driver(specialix_driver);
@@ -2457,7 +2455,7 @@ static int sx_init_drivers(void)
                 init_waitqueue_head(&sx_port[i].close_wait);
                 spin_lock_init(&sx_port[i].lock);
         }
-        
+
         func_exit();
         return 0;
 }
@@ -2472,8 +2470,8 @@ static void sx_release_drivers(void)
         func_exit();
 }
 
-/* 
- * This routine must be called by kernel at boot time 
+/*
+ * This routine must be called by kernel at boot time
  */
 static int __init specialix_init(void)
 {
@@ -2489,7 +2487,7 @@ static int __init specialix_init(void)
 #else
         printk (KERN_INFO "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
 #endif
-        
+
         for (i = 0; i < SX_NBOARD; i++)
                 sx_board[i].lock = SPIN_LOCK_UNLOCKED;
 
@@ -2498,7 +2496,7 @@ static int __init specialix_init(void)
                 return -EIO;
         }
 
-        for (i = 0; i < SX_NBOARD; i++) 
+        for (i = 0; i < SX_NBOARD; i++)
                 if (sx_board[i].base && !sx_probe(&sx_board[i]))
                         found++;
 
@@ -2512,8 +2510,8 @@ static int __init specialix_init(void)
                                 i++;
                                 continue;
                         }
-                        pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX, 
-                                                PCI_DEVICE_ID_SPECIALIX_IO8, 
+                        pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
+                                                PCI_DEVICE_ID_SPECIALIX_IO8,
                                                 pdev);
                         if (!pdev) break;
 
@@ -2557,10 +2555,10 @@ module_param(sx_poll, int, 0);
 /*
  * You can setup up to 4 boards.
  * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
- * You should specify the IRQs too in that case "irq=....,...". 
- * 
+ * You should specify the IRQs too in that case "irq=....,...".
+ *
  * More than 4 boards in one computer is not possible, as the card can
- * only use 4 different interrupts. 
+ * only use 4 different interrupts.
  *
  */
 static int __init specialix_init_module(void)
@@ -2583,16 +2581,16 @@ static int __init specialix_init_module(void)
 
         return specialix_init();
 }
-        
+
 static void __exit specialix_exit_module(void)
 {
         int i;
-        
+
         func_enter();
 
         sx_release_drivers();
         for (i = 0; i < SX_NBOARD; i++)
-                if (sx_board[i].flags & SX_BOARD_PRESENT) 
+                if (sx_board[i].flags & SX_BOARD_PRESENT)
                         sx_release_io_range(&sx_board[i]);
 #ifdef SPECIALIX_TIMER
         del_timer (&missed_irq_timer);
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index ea2d54be4843..0133dc0e25d0 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -912,6 +912,7 @@ MODULE_DEVICE_TABLE(pci, synclink_pci_tbl);
 MODULE_LICENSE("GPL");
 
 static struct pci_driver synclink_pci_driver = {
+        .owner          = THIS_MODULE,
         .name           = "synclink",
         .id_table       = synclink_pci_tbl,
         .probe          = synclink_init_one,
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 6fb165cf8a61..f185724448b1 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -500,6 +500,7 @@ MODULE_DEVICE_TABLE(pci, synclinkmp_pci_tbl);
 MODULE_LICENSE("GPL");
 
 static struct pci_driver synclinkmp_pci_driver = {
+        .owner          = THIS_MODULE,
         .name           = "synclinkmp",
         .id_table       = synclinkmp_pci_tbl,
         .probe          = synclinkmp_init_one,
diff --git a/drivers/char/tlclk.c b/drivers/char/tlclk.c
new file mode 100644
index 000000000000..18cdd4361dc6
--- /dev/null
+++ b/drivers/char/tlclk.c
@@ -0,0 +1,896 @@
+/*
+ * Telecom Clock driver for Intel NetStructure(tm) MPCBL0010
+ *
+ * Copyright (C) 2005 Kontron Canada
+ *
+ * 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, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Send feedback to <sebastien.bouchard@ca.kontron.com> and the current
+ * Maintainer  <mark.gross@intel.com>
+ *
+ * Description : This is the TELECOM CLOCK module driver for the ATCA
+ * MPCBL0010 ATCA computer.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>       /* printk() */
+#include <linux/fs.h>           /* everything... */
+#include <linux/errno.h>        /* error codes */
+#include <linux/delay.h>        /* udelay */
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/sysfs.h>
+#include <linux/device.h>
+#include <linux/miscdevice.h>
+#include <asm/io.h>             /* inb/outb */
+#include <asm/uaccess.h>
+
+MODULE_AUTHOR("Sebastien Bouchard <sebastien.bouchard@ca.kontron.com>");
+MODULE_LICENSE("GPL");
+
+/*Hardware Reset of the PLL */
+#define RESET_ON        0x00
+#define RESET_OFF       0x01
+
+/* MODE SELECT */
+#define NORMAL_MODE     0x00
+#define HOLDOVER_MODE   0x10
+#define FREERUN_MODE    0x20
+
+/* FILTER SELECT */
+#define FILTER_6HZ      0x04
+#define FILTER_12HZ     0x00
+
+/* SELECT REFERENCE FREQUENCY */
+#define REF_CLK1_8kHz           0x00
+#define REF_CLK2_19_44MHz       0x02
+
+/* Select primary or secondary redundant clock */
+#define PRIMARY_CLOCK   0x00
+#define SECONDARY_CLOCK 0x01
+
+/* CLOCK TRANSMISSION DEFINE */
+#define CLK_8kHz        0xff
+#define CLK_16_384MHz   0xfb
+
+#define CLK_1_544MHz    0x00
+#define CLK_2_048MHz    0x01
+#define CLK_4_096MHz    0x02
+#define CLK_6_312MHz    0x03
+#define CLK_8_192MHz    0x04
+#define CLK_19_440MHz   0x06
+
+#define CLK_8_592MHz    0x08
+#define CLK_11_184MHz   0x09
+#define CLK_34_368MHz   0x0b
+#define CLK_44_736MHz   0x0a
+
+/* RECEIVED REFERENCE */
+#define AMC_B1 0
+#define AMC_B2 1
+
+/* HARDWARE SWITCHING DEFINE */
+#define HW_ENABLE       0x80
+#define HW_DISABLE      0x00
+
+/* HARDWARE SWITCHING MODE DEFINE */
+#define PLL_HOLDOVER    0x40
+#define LOST_CLOCK      0x00
+
+/* ALARMS DEFINE */
+#define UNLOCK_MASK     0x10
+#define HOLDOVER_MASK   0x20
+#define SEC_LOST_MASK   0x40
+#define PRI_LOST_MASK   0x80
+
+/* INTERRUPT CAUSE DEFINE */
+
+#define PRI_LOS_01_MASK         0x01
+#define PRI_LOS_10_MASK         0x02
+
+#define SEC_LOS_01_MASK         0x04
+#define SEC_LOS_10_MASK         0x08
+
+#define HOLDOVER_01_MASK        0x10
+#define HOLDOVER_10_MASK        0x20
+
+#define UNLOCK_01_MASK          0x40
+#define UNLOCK_10_MASK          0x80
+
+struct tlclk_alarms {
+        __u32 lost_clocks;
+        __u32 lost_primary_clock;
+        __u32 lost_secondary_clock;
+        __u32 primary_clock_back;
+        __u32 secondary_clock_back;
+        __u32 switchover_primary;
+        __u32 switchover_secondary;
+        __u32 pll_holdover;
+        __u32 pll_end_holdover;
+        __u32 pll_lost_sync;
+        __u32 pll_sync;
+};
+/* Telecom clock I/O register definition */
+#define TLCLK_BASE 0xa08
+#define TLCLK_REG0 TLCLK_BASE
+#define TLCLK_REG1 (TLCLK_BASE+1)
+#define TLCLK_REG2 (TLCLK_BASE+2)
+#define TLCLK_REG3 (TLCLK_BASE+3)
+#define TLCLK_REG4 (TLCLK_BASE+4)
+#define TLCLK_REG5 (TLCLK_BASE+5)
+#define TLCLK_REG6 (TLCLK_BASE+6)
+#define TLCLK_REG7 (TLCLK_BASE+7)
+
+#define SET_PORT_BITS(port, mask, val) outb(((inb(port) & mask) | val), port)
+
+/* 0 = Dynamic allocation of the major device number */
+#define TLCLK_MAJOR 0
+
+/* sysfs interface definition:
+Upon loading the driver will create a sysfs directory under
+/sys/devices/platform/telco_clock.
+
+This directory exports the following interfaces.  There operation is
+documented in the MCPBL0010 TPS under the Telecom Clock API section, 11.4.
+alarms                          :
+current_ref                     :
+enable_clk3a_output             :
+enable_clk3b_output             :
+enable_clka0_output             :
+enable_clka1_output             :
+enable_clkb0_output             :
+enable_clkb1_output             :
+filter_select                   :
+hardware_switching              :
+hardware_switching_mode         :
+interrupt_switch                :
+mode_select                     :
+refalign                        :
+reset                           :
+select_amcb1_transmit_clock     :
+select_amcb2_transmit_clock     :
+select_redundant_clock          :
+select_ref_frequency            :
+test_mode                       :
+
+All sysfs interfaces are integers in hex format, i.e echo 99 > refalign
+has the same effect as echo 0x99 > refalign.
+*/
+
+static unsigned int telclk_interrupt;
+
+static int int_events;          /* Event that generate a interrupt */
+static int got_event;           /* if events processing have been done */
+
+static void switchover_timeout(unsigned long data);
+static struct timer_list switchover_timer =
+        TIMER_INITIALIZER(switchover_timeout , 0, 0);
+
+static struct tlclk_alarms *alarm_events;
+
+static DEFINE_SPINLOCK(event_lock);
+
+static int tlclk_major = TLCLK_MAJOR;
+
+static irqreturn_t tlclk_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+
+static DECLARE_WAIT_QUEUE_HEAD(wq);
+
+static int tlclk_open(struct inode *inode, struct file *filp)
+{
+        int result;
+
+        /* Make sure there is no interrupt pending while
+         * initialising interrupt handler */
+        inb(TLCLK_REG6);
+
+        /* This device is wired through the FPGA IO space of the ATCA blade
+         * we can't share this IRQ */
+        result = request_irq(telclk_interrupt, &tlclk_interrupt,
+                             SA_INTERRUPT, "telco_clock", tlclk_interrupt);
+        if (result == -EBUSY) {
+                printk(KERN_ERR "telco_clock: Interrupt can't be reserved!\n");
+                return -EBUSY;
+        }
+        inb(TLCLK_REG6);        /* Clear interrupt events */
+
+        return 0;
+}
+
+static int tlclk_release(struct inode *inode, struct file *filp)
+{
+        free_irq(telclk_interrupt, tlclk_interrupt);
+
+        return 0;
+}
+
+ssize_t tlclk_read(struct file *filp, char __user *buf, size_t count,
+                loff_t *f_pos)
+{
+        if (count < sizeof(struct tlclk_alarms))
+                return -EIO;
+
+        wait_event_interruptible(wq, got_event);
+        if (copy_to_user(buf, alarm_events, sizeof(struct tlclk_alarms)))
+                return -EFAULT;
+
+        memset(alarm_events, 0, sizeof(struct tlclk_alarms));
+        got_event = 0;
+
+        return  sizeof(struct tlclk_alarms);
+}
+
+ssize_t tlclk_write(struct file *filp, const char __user *buf, size_t count,
+            loff_t *f_pos)
+{
+        return 0;
+}
+
+static struct file_operations tlclk_fops = {
+        .read = tlclk_read,
+        .write = tlclk_write,
+        .open = tlclk_open,
+        .release = tlclk_release,
+
+};
+
+static struct miscdevice tlclk_miscdev = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = "telco_clock",
+        .fops = &tlclk_fops,
+};
+
+static ssize_t show_current_ref(struct device *d,
+                struct device_attribute *attr, char *buf)
+{
+        unsigned long ret_val;
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        ret_val = ((inb(TLCLK_REG1) & 0x08) >> 3);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return sprintf(buf, "0x%lX\n", ret_val);
+}
+
+static DEVICE_ATTR(current_ref, S_IRUGO, show_current_ref, NULL);
+
+
+static ssize_t show_interrupt_switch(struct device *d,
+                struct device_attribute *attr, char *buf)
+{
+        unsigned long ret_val;
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        ret_val = inb(TLCLK_REG6);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return sprintf(buf, "0x%lX\n", ret_val);
+}
+
+static DEVICE_ATTR(interrupt_switch, S_IRUGO,
+                show_interrupt_switch, NULL);
+
+static ssize_t show_alarms(struct device *d,
+                struct device_attribute *attr,  char *buf)
+{
+        unsigned long ret_val;
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        ret_val = (inb(TLCLK_REG2) & 0xf0);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return sprintf(buf, "0x%lX\n", ret_val);
+}
+
+static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
+
+static ssize_t store_enable_clk3b_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, ": tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG3, 0x7f, val << 7);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clk3b_output, S_IWUGO, NULL,
+                store_enable_clk3b_output);
+
+static ssize_t store_enable_clk3a_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG3, 0xbf, val << 6);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clk3a_output, S_IWUGO, NULL,
+                store_enable_clk3a_output);
+
+static ssize_t store_enable_clkb1_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xf7, val << 3);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clkb1_output, S_IWUGO, NULL,
+                store_enable_clkb1_output);
+
+
+static ssize_t store_enable_clka1_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xfb, val << 2);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clka1_output, S_IWUGO, NULL,
+                store_enable_clka1_output);
+
+static ssize_t store_enable_clkb0_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xfd, val << 1);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clkb0_output, S_IWUGO, NULL,
+                store_enable_clkb0_output);
+
+static ssize_t store_enable_clka0_output(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG2, 0xfe, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(enable_clka0_output, S_IWUGO, NULL,
+                store_enable_clka0_output);
+
+static ssize_t store_test_mode(struct device *d,
+                struct device_attribute *attr,  const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG4, 0xfd, 2);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(test_mode, S_IWUGO, NULL, store_test_mode);
+
+static ssize_t store_select_amcb2_transmit_clock(struct device *d,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long flags;
+        unsigned long tmp;
+        unsigned char val;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+                if ((val == CLK_8kHz) || (val == CLK_16_384MHz)) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xc7, 0x28);
+                        SET_PORT_BITS(TLCLK_REG1, 0xfb, ~val);
+                } else if (val >= CLK_8_592MHz) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xc7, 0x38);
+                        switch (val) {
+                        case CLK_8_592MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 1);
+                                break;
+                        case CLK_11_184MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 0);
+                                break;
+                        case CLK_34_368MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 3);
+                                break;
+                        case CLK_44_736MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 2);
+                                break;
+                        }
+                } else
+                        SET_PORT_BITS(TLCLK_REG3, 0xc7, val << 3);
+
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_amcb2_transmit_clock, S_IWUGO, NULL,
+        store_select_amcb2_transmit_clock);
+
+static ssize_t store_select_amcb1_transmit_clock(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+                if ((val == CLK_8kHz) || (val == CLK_16_384MHz)) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xf8, 0x5);
+                        SET_PORT_BITS(TLCLK_REG1, 0xfb, ~val);
+                } else if (val >= CLK_8_592MHz) {
+                        SET_PORT_BITS(TLCLK_REG3, 0xf8, 0x7);
+                        switch (val) {
+                        case CLK_8_592MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 1);
+                                break;
+                        case CLK_11_184MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 0);
+                                break;
+                        case CLK_34_368MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 3);
+                                break;
+                        case CLK_44_736MHz:
+                                SET_PORT_BITS(TLCLK_REG0, 0xfc, 2);
+                                break;
+                        }
+                } else
+                        SET_PORT_BITS(TLCLK_REG3, 0xf8, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_amcb1_transmit_clock, S_IWUGO, NULL,
+                store_select_amcb1_transmit_clock);
+
+static ssize_t store_select_redundant_clock(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG1, 0xfe, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_redundant_clock, S_IWUGO, NULL,
+                store_select_redundant_clock);
+
+static ssize_t store_select_ref_frequency(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG1, 0xfd, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(select_ref_frequency, S_IWUGO, NULL,
+                store_select_ref_frequency);
+
+static ssize_t store_filter_select(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xfb, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(filter_select, S_IWUGO, NULL, store_filter_select);
+
+static ssize_t store_hardware_switching_mode(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xbf, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(hardware_switching_mode, S_IWUGO, NULL,
+                store_hardware_switching_mode);
+
+static ssize_t store_hardware_switching(struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0x7f, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(hardware_switching, S_IWUGO, NULL,
+                store_hardware_switching);
+
+static ssize_t store_refalign (struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xf7, 0);
+        udelay(2);
+        SET_PORT_BITS(TLCLK_REG0, 0xf7, 0x08);
+        udelay(2);
+        SET_PORT_BITS(TLCLK_REG0, 0xf7, 0);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(refalign, S_IWUGO, NULL, store_refalign);
+
+static ssize_t store_mode_select (struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG0, 0xcf, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(mode_select, S_IWUGO, NULL, store_mode_select);
+
+static ssize_t store_reset (struct device *d,
+                 struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long tmp;
+        unsigned char val;
+        unsigned long flags;
+
+        sscanf(buf, "%lX", &tmp);
+        dev_dbg(d, "tmp = 0x%lX\n", tmp);
+
+        val = (unsigned char)tmp;
+        spin_lock_irqsave(&event_lock, flags);
+        SET_PORT_BITS(TLCLK_REG4, 0xfd, val);
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(reset, S_IWUGO, NULL, store_reset);
+
+static struct attribute *tlclk_sysfs_entries[] = {
+        &dev_attr_current_ref.attr,
+        &dev_attr_interrupt_switch.attr,
+        &dev_attr_alarms.attr,
+        &dev_attr_enable_clk3a_output.attr,
+        &dev_attr_enable_clk3b_output.attr,
+        &dev_attr_enable_clkb1_output.attr,
+        &dev_attr_enable_clka1_output.attr,
+        &dev_attr_enable_clkb0_output.attr,
+        &dev_attr_enable_clka0_output.attr,
+        &dev_attr_test_mode.attr,
+        &dev_attr_select_amcb1_transmit_clock.attr,
+        &dev_attr_select_amcb2_transmit_clock.attr,
+        &dev_attr_select_redundant_clock.attr,
+        &dev_attr_select_ref_frequency.attr,
+        &dev_attr_filter_select.attr,
+        &dev_attr_hardware_switching_mode.attr,
+        &dev_attr_hardware_switching.attr,
+        &dev_attr_refalign.attr,
+        &dev_attr_mode_select.attr,
+        &dev_attr_reset.attr,
+        NULL
+};
+
+static struct attribute_group tlclk_attribute_group = {
+        .name = NULL,           /* put in device directory */
+        .attrs = tlclk_sysfs_entries,
+};
+
+static struct platform_device *tlclk_device;
+
+static int __init tlclk_init(void)
+{
+        int ret;
+
+        ret = register_chrdev(tlclk_major, "telco_clock", &tlclk_fops);
+        if (ret < 0) {
+                printk(KERN_ERR "telco_clock: can't get major! %d\n", tlclk_major);
+                return ret;
+        }
+        alarm_events = kzalloc( sizeof(struct tlclk_alarms), GFP_KERNEL);
+        if (!alarm_events)
+                goto out1;
+
+        /* Read telecom clock IRQ number (Set by BIOS) */
+        if (!request_region(TLCLK_BASE, 8, "telco_clock")) {
+                printk(KERN_ERR "tlclk: request_region failed! 0x%X\n",
+                        TLCLK_BASE);
+                ret = -EBUSY;
+                goto out2;
+        }
+        telclk_interrupt = (inb(TLCLK_REG7) & 0x0f);
+
+        if (0x0F == telclk_interrupt ) { /* not MCPBL0010 ? */
+                printk(KERN_ERR "telclk_interrup = 0x%x non-mcpbl0010 hw\n",
+                        telclk_interrupt);
+                ret = -ENXIO;
+                goto out3;
+        }
+
+        init_timer(&switchover_timer);
+
+        ret = misc_register(&tlclk_miscdev);
+        if (ret < 0) {
+                printk(KERN_ERR " misc_register retruns %d\n", ret);
+                ret = -EBUSY;
+                goto out3;
+        }
+
+        tlclk_device = platform_device_register_simple("telco_clock",
+                                -1, NULL, 0);
+        if (!tlclk_device) {
+                printk(KERN_ERR " platform_device_register retruns 0x%X\n",
+                        (unsigned int) tlclk_device);
+                ret = -EBUSY;
+                goto out4;
+        }
+
+        ret = sysfs_create_group(&tlclk_device->dev.kobj,
+                        &tlclk_attribute_group);
+        if (ret) {
+                printk(KERN_ERR "failed to create sysfs device attributes\n");
+                sysfs_remove_group(&tlclk_device->dev.kobj,
+                        &tlclk_attribute_group);
+                goto out5;
+        }
+
+        return 0;
+out5:
+        platform_device_unregister(tlclk_device);
+out4:
+        misc_deregister(&tlclk_miscdev);
+out3:
+        release_region(TLCLK_BASE, 8);
+out2:
+        kfree(alarm_events);
+out1:
+        unregister_chrdev(tlclk_major, "telco_clock");
+        return ret;
+}
+
+static void __exit tlclk_cleanup(void)
+{
+        sysfs_remove_group(&tlclk_device->dev.kobj, &tlclk_attribute_group);
+        platform_device_unregister(tlclk_device);
+        misc_deregister(&tlclk_miscdev);
+        unregister_chrdev(tlclk_major, "telco_clock");
+
+        release_region(TLCLK_BASE, 8);
+        del_timer_sync(&switchover_timer);
+        kfree(alarm_events);
+
+}
+
+static void switchover_timeout(unsigned long data)
+{
+        if ((data & 1)) {
+                if ((inb(TLCLK_REG1) & 0x08) != (data & 0x08))
+                        alarm_events->switchover_primary++;
+        } else {
+                if ((inb(TLCLK_REG1) & 0x08) != (data & 0x08))
+                        alarm_events->switchover_secondary++;
+        }
+
+        /* Alarm processing is done, wake up read task */
+        del_timer(&switchover_timer);
+        got_event = 1;
+        wake_up(&wq);
+}
+
+static irqreturn_t tlclk_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&event_lock, flags);
+        /* Read and clear interrupt events */
+        int_events = inb(TLCLK_REG6);
+
+        /* Primary_Los changed from 0 to 1 ? */
+        if (int_events & PRI_LOS_01_MASK) {
+                if (inb(TLCLK_REG2) & SEC_LOST_MASK)
+                        alarm_events->lost_clocks++;
+                else
+                        alarm_events->lost_primary_clock++;
+        }
+
+        /* Primary_Los changed from 1 to 0 ? */
+        if (int_events & PRI_LOS_10_MASK) {
+                alarm_events->primary_clock_back++;
+                SET_PORT_BITS(TLCLK_REG1, 0xFE, 1);
+        }
+        /* Secondary_Los changed from 0 to 1 ? */
+        if (int_events & SEC_LOS_01_MASK) {
+                if (inb(TLCLK_REG2) & PRI_LOST_MASK)
+                        alarm_events->lost_clocks++;
+                else
+                        alarm_events->lost_secondary_clock++;
+        }
+        /* Secondary_Los changed from 1 to 0 ? */
+        if (int_events & SEC_LOS_10_MASK) {
+                alarm_events->secondary_clock_back++;
+                SET_PORT_BITS(TLCLK_REG1, 0xFE, 0);
+        }
+        if (int_events & HOLDOVER_10_MASK)
+                alarm_events->pll_end_holdover++;
+
+        if (int_events & UNLOCK_01_MASK)
+                alarm_events->pll_lost_sync++;
+
+        if (int_events & UNLOCK_10_MASK)
+                alarm_events->pll_sync++;
+
+        /* Holdover changed from 0 to 1 ? */
+        if (int_events & HOLDOVER_01_MASK) {
+                alarm_events->pll_holdover++;
+
+                /* TIMEOUT in ~10ms */
+                switchover_timer.expires = jiffies + msecs_to_jiffies(10);
+                switchover_timer.data = inb(TLCLK_REG1);
+                add_timer(&switchover_timer);
+        } else {
+                got_event = 1;
+                wake_up(&wq);
+        }
+        spin_unlock_irqrestore(&event_lock, flags);
+
+        return IRQ_HANDLED;
+}
+
+module_init(tlclk_init);
+module_exit(tlclk_cleanup);
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 049d128ae7f0..303f15880466 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -64,7 +64,7 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         if (count == 0)
                 return -ENODATA;
         if (count > bufsiz) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "invalid count value %x %zx \n", count, bufsiz);
                 return -E2BIG;
         }
@@ -72,21 +72,21 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         down(&chip->tpm_mutex);
 
         if ((rc = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "tpm_transmit: tpm_send: error %zd\n", rc);
                 goto out;
         }
 
         stop = jiffies + 2 * 60 * HZ;
         do {
-                u8 status = inb(chip->vendor->base + 1);
+                u8 status = chip->vendor->status(chip);
                 if ((status & chip->vendor->req_complete_mask) ==
                     chip->vendor->req_complete_val) {
                         goto out_recv;
                 }
 
                 if ((status == chip->vendor->req_canceled)) {
-                        dev_err(&chip->pci_dev->dev, "Operation Canceled\n");
+                        dev_err(chip->dev, "Operation Canceled\n");
                         rc = -ECANCELED;
                         goto out;
                 }
@@ -97,14 +97,14 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
 
 
         chip->vendor->cancel(chip);
-        dev_err(&chip->pci_dev->dev, "Operation Timed out\n");
+        dev_err(chip->dev, "Operation Timed out\n");
         rc = -ETIME;
         goto out;
 
 out_recv:
         rc = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
         if (rc < 0)
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "tpm_transmit: tpm_recv: error %zd\n", rc);
 out:
         up(&chip->tpm_mutex);
@@ -139,15 +139,14 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
         __be32 index;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
         memcpy(data, cap_pcr, sizeof(cap_pcr));
         if ((len = tpm_transmit(chip, data, sizeof(data)))
             < CAP_PCR_RESULT_SIZE) {
-                dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred "
+                dev_dbg(chip->dev, "A TPM error (%d) occurred "
                                 "attempting to determine the number of PCRS\n",
                         be32_to_cpu(*((__be32 *) (data + 6))));
                 return 0;
@@ -161,9 +160,10 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
                 memcpy(data + 10, &index, 4);
                 if ((len = tpm_transmit(chip, data, sizeof(data)))
                     < READ_PCR_RESULT_SIZE){
-                        dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred"
+                        dev_dbg(chip->dev, "A TPM error (%d) occurred"
                                 " attempting to read PCR %d of %d\n",
-                                be32_to_cpu(*((__be32 *) (data + 6))), i, num_pcrs);
+                                be32_to_cpu(*((__be32 *) (data + 6))),
+                                i, num_pcrs);
                         goto out;
                 }
                 str += sprintf(str, "PCR-%02d: ", i);
@@ -191,21 +191,19 @@ ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr,
         int i, rc;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
-        data = kmalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
+        data = kzalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
         memcpy(data, readpubek, sizeof(readpubek));
-        memset(data + sizeof(readpubek), 0, 20);        /* zero nonce */
 
         if ((len = tpm_transmit(chip, data, READ_PUBEK_RESULT_SIZE)) <
             READ_PUBEK_RESULT_SIZE) {
-                dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred "
+                dev_dbg(chip->dev, "A TPM error (%d) occurred "
                                 "attempting to read the PUBEK\n",
                             be32_to_cpu(*((__be32 *) (data + 6))));
                 rc = 0;
@@ -245,7 +243,6 @@ out:
         kfree(data);
         return rc;
 }
-
 EXPORT_SYMBOL_GPL(tpm_show_pubek);
 
 #define CAP_VER_RESULT_SIZE 18
@@ -274,8 +271,7 @@ ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
         ssize_t len;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
@@ -315,7 +311,6 @@ ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
 }
 EXPORT_SYMBOL_GPL(tpm_store_cancel);
 
-
 /*
  * Device file system interface to the TPM
  */
@@ -339,21 +334,20 @@ int tpm_open(struct inode *inode, struct file *file)
         }
 
         if (chip->num_opens) {
-                dev_dbg(&chip->pci_dev->dev,
-                        "Another process owns this TPM\n");
+                dev_dbg(chip->dev, "Another process owns this TPM\n");
                 rc = -EBUSY;
                 goto err_out;
         }
 
         chip->num_opens++;
-        pci_dev_get(chip->pci_dev);
+        get_device(chip->dev);
 
         spin_unlock(&driver_lock);
 
         chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
         if (chip->data_buffer == NULL) {
                 chip->num_opens--;
-                pci_dev_put(chip->pci_dev);
+                put_device(chip->dev);
                 return -ENOMEM;
         }
 
@@ -366,7 +360,6 @@ err_out:
         spin_unlock(&driver_lock);
         return rc;
 }
-
 EXPORT_SYMBOL_GPL(tpm_open);
 
 int tpm_release(struct inode *inode, struct file *file)
@@ -378,15 +371,14 @@ int tpm_release(struct inode *inode, struct file *file)
         chip->num_opens--;
         del_singleshot_timer_sync(&chip->user_read_timer);
         atomic_set(&chip->data_pending, 0);
-        pci_dev_put(chip->pci_dev);
+        put_device(chip->dev);
         kfree(chip->data_buffer);
         spin_unlock(&driver_lock);
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_release);
 
-ssize_t tpm_write(struct file * file, const char __user * buf,
+ssize_t tpm_write(struct file *file, const char __user *buf,
                   size_t size, loff_t * off)
 {
         struct tpm_chip *chip = file->private_data;
@@ -422,7 +414,7 @@ ssize_t tpm_write(struct file * file, const char __user * buf,
 
 EXPORT_SYMBOL_GPL(tpm_write);
 
-ssize_t tpm_read(struct file * file, char __user * buf,
+ssize_t tpm_read(struct file * file, char __user *buf,
                  size_t size, loff_t * off)
 {
         struct tpm_chip *chip = file->private_data;
@@ -444,15 +436,14 @@ ssize_t tpm_read(struct file * file, char __user * buf,
 
         return ret_size;
 }
-
 EXPORT_SYMBOL_GPL(tpm_read);
 
-void __devexit tpm_remove(struct pci_dev *pci_dev)
+void tpm_remove_hardware(struct device *dev)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip == NULL) {
-                dev_err(&pci_dev->dev, "No device data found\n");
+                dev_err(dev, "No device data found\n");
                 return;
         }
 
@@ -462,22 +453,20 @@ void __devexit tpm_remove(struct pci_dev *pci_dev)
 
         spin_unlock(&driver_lock);
 
-        pci_set_drvdata(pci_dev, NULL);
+        dev_set_drvdata(dev, NULL);
         misc_deregister(&chip->vendor->miscdev);
         kfree(chip->vendor->miscdev.name);
 
-        sysfs_remove_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
+        sysfs_remove_group(&dev->kobj, chip->vendor->attr_group);
 
-        pci_disable_device(pci_dev);
-
-        dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &= !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
+        dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &=
+                !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
 
         kfree(chip);
 
-        pci_dev_put(pci_dev);
+        put_device(dev);
 }
-
-EXPORT_SYMBOL_GPL(tpm_remove);
+EXPORT_SYMBOL_GPL(tpm_remove_hardware);
 
 static u8 savestate[] = {
         0, 193,                 /* TPM_TAG_RQU_COMMAND */
@@ -489,32 +478,30 @@ static u8 savestate[] = {
  * We are about to suspend. Save the TPM state
  * so that it can be restored.
  */
-int tpm_pm_suspend(struct pci_dev *pci_dev, pm_message_t pm_state)
+int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
         tpm_transmit(chip, savestate, sizeof(savestate));
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
 
 /*
  * Resume from a power safe. The BIOS already restored
  * the TPM state.
  */
-int tpm_pm_resume(struct pci_dev *pci_dev)
+int tpm_pm_resume(struct device *dev)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip == NULL)
                 return -ENODEV;
 
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_pm_resume);
 
 /*
@@ -524,8 +511,7 @@ EXPORT_SYMBOL_GPL(tpm_pm_resume);
  * upon errant exit from this function specific probe function should call
  * pci_disable_device
  */
-int tpm_register_hardware(struct pci_dev *pci_dev,
-                          struct tpm_vendor_specific *entry)
+int tpm_register_hardware(struct device *dev, struct tpm_vendor_specific *entry)
 {
 #define DEVNAME_SIZE 7
 
@@ -534,12 +520,10 @@ int tpm_register_hardware(struct pci_dev *pci_dev,
         int i, j;
 
         /* Driver specific per-device data */
-        chip = kmalloc(sizeof(*chip), GFP_KERNEL);
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (chip == NULL)
                 return -ENOMEM;
 
-        memset(chip, 0, sizeof(struct tpm_chip));
-
         init_MUTEX(&chip->buffer_mutex);
         init_MUTEX(&chip->tpm_mutex);
         INIT_LIST_HEAD(&chip->list);
@@ -563,8 +547,7 @@ int tpm_register_hardware(struct pci_dev *pci_dev,
 
 dev_num_search_complete:
         if (chip->dev_num < 0) {
-                dev_err(&pci_dev->dev,
-                        "No available tpm device numbers\n");
+                dev_err(dev, "No available tpm device numbers\n");
                 kfree(chip);
                 return -ENODEV;
         } else if (chip->dev_num == 0)
@@ -576,15 +559,15 @@ dev_num_search_complete:
         scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
         chip->vendor->miscdev.name = devname;
 
-        chip->vendor->miscdev.dev = &(pci_dev->dev);
-        chip->pci_dev = pci_dev_get(pci_dev);
+        chip->vendor->miscdev.dev = dev;
+        chip->dev = get_device(dev);
 
         if (misc_register(&chip->vendor->miscdev)) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "unable to misc_register %s, minor %d\n",
                         chip->vendor->miscdev.name,
                         chip->vendor->miscdev.minor);
-                pci_dev_put(pci_dev);
+                put_device(dev);
                 kfree(chip);
                 dev_mask[i] &= !(1 << j);
                 return -ENODEV;
@@ -592,17 +575,16 @@ dev_num_search_complete:
 
         spin_lock(&driver_lock);
 
-        pci_set_drvdata(pci_dev, chip);
+        dev_set_drvdata(dev, chip);
 
         list_add(&chip->list, &tpm_chip_list);
 
         spin_unlock(&driver_lock);
 
-        sysfs_create_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
+        sysfs_create_group(&dev->kobj, chip->vendor->attr_group);
 
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_register_hardware);
 
 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 373b41f6b460..024814b50c3c 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -55,12 +55,13 @@ struct tpm_vendor_specific {
         int (*recv) (struct tpm_chip *, u8 *, size_t);
         int (*send) (struct tpm_chip *, u8 *, size_t);
         void (*cancel) (struct tpm_chip *);
+        u8 (*status) (struct tpm_chip *);
         struct miscdevice miscdev;
         struct attribute_group *attr_group;
 };
 
 struct tpm_chip {
-        struct pci_dev *pci_dev;        /* PCI device stuff */
+        struct device *dev;     /* Device stuff */
 
         int dev_num;            /* /dev/tpm# */
         int num_opens;          /* only one allowed */
@@ -91,13 +92,13 @@ static inline void tpm_write_index(int base, int index, int value)
         outb(value & 0xFF, base+1);
 }
 
-extern int tpm_register_hardware(struct pci_dev *,
+extern int tpm_register_hardware(struct device *,
                                  struct tpm_vendor_specific *);
 extern int tpm_open(struct inode *, struct file *);
 extern int tpm_release(struct inode *, struct file *);
 extern ssize_t tpm_write(struct file *, const char __user *, size_t,
                          loff_t *);
 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
-extern void __devexit tpm_remove(struct pci_dev *);
-extern int tpm_pm_suspend(struct pci_dev *, pm_message_t);
-extern int tpm_pm_resume(struct pci_dev *);
+extern void tpm_remove_hardware(struct device *);
+extern int tpm_pm_suspend(struct device *, pm_message_t);
+extern int tpm_pm_resume(struct device *);
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index c0d64914595f..8cb42e84723c 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -40,7 +40,7 @@ enum tpm_atmel_read_status {
         ATML_STATUS_READY = 0x08
 };
 
-static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
+static int tpm_atml_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         u8 status, *hdr = buf;
         u32 size;
@@ -54,7 +54,7 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (i = 0; i < 6; i++) {
                 status = inb(chip->vendor->base + 1);
                 if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "error reading header\n");
                         return -EIO;
                 }
@@ -66,12 +66,12 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         size = be32_to_cpu(*native_size);
 
         if (count < size) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "Recv size(%d) less than available space\n", size);
                 for (; i < size; i++) { /* clear the waiting data anyway */
                         status = inb(chip->vendor->base + 1);
                         if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                                dev_err(&chip->pci_dev->dev,
+                                dev_err(chip->dev,
                                         "error reading data\n");
                                 return -EIO;
                         }
@@ -83,7 +83,7 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (; i < size; i++) {
                 status = inb(chip->vendor->base + 1);
                 if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "error reading data\n");
                         return -EIO;
                 }
@@ -93,20 +93,20 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         /* make sure data available is gone */
         status = inb(chip->vendor->base + 1);
         if (status & ATML_STATUS_DATA_AVAIL) {
-                dev_err(&chip->pci_dev->dev, "data available is stuck\n");
+                dev_err(chip->dev, "data available is stuck\n");
                 return -EIO;
         }
 
         return size;
 }
 
-static int tpm_atml_send(struct tpm_chip *chip, u8 * buf, size_t count)
+static int tpm_atml_send(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         int i;
 
-        dev_dbg(&chip->pci_dev->dev, "tpm_atml_send: ");
+        dev_dbg(chip->dev, "tpm_atml_send:\n");
         for (i = 0; i < count; i++) {
-                dev_dbg(&chip->pci_dev->dev, "0x%x(%d) ", buf[i], buf[i]);
+                dev_dbg(chip->dev, "%d 0x%x(%d)\n",  i, buf[i], buf[i]);
                 outb(buf[i], chip->vendor->base);
         }
 
@@ -118,6 +118,11 @@ static void tpm_atml_cancel(struct tpm_chip *chip)
         outb(ATML_STATUS_ABORT, chip->vendor->base + 1);
 }
 
+static u8 tpm_atml_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + 1);
+}
+
 static struct file_operations atmel_ops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
@@ -137,7 +142,7 @@ static struct attribute* atmel_attrs[] = {
         &dev_attr_pcrs.attr,
         &dev_attr_caps.attr,
         &dev_attr_cancel.attr,
-        0,
+        NULL,
 };
 
 static struct attribute_group atmel_attr_grp = { .attrs = atmel_attrs };
@@ -146,6 +151,7 @@ static struct tpm_vendor_specific tpm_atmel = {
         .recv = tpm_atml_recv,
         .send = tpm_atml_send,
         .cancel = tpm_atml_cancel,
+        .status = tpm_atml_status,
         .req_complete_mask = ATML_STATUS_BUSY | ATML_STATUS_DATA_AVAIL,
         .req_complete_val = ATML_STATUS_DATA_AVAIL,
         .req_canceled = ATML_STATUS_READY,
@@ -153,86 +159,94 @@ static struct tpm_vendor_specific tpm_atmel = {
         .miscdev = { .fops = &atmel_ops, },
 };
 
-static int __devinit tpm_atml_init(struct pci_dev *pci_dev,
-                                   const struct pci_device_id *pci_id)
+static struct platform_device *pdev;
+
+static void __devexit tpm_atml_remove(struct device *dev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(dev);
+        if (chip) {
+                release_region(chip->vendor->base, 2);
+                tpm_remove_hardware(chip->dev);
+        }
+}
+
+static struct device_driver atml_drv = {
+        .name = "tpm_atmel",
+        .bus = &platform_bus_type,
+        .owner = THIS_MODULE,
+        .suspend = tpm_pm_suspend,
+        .resume = tpm_pm_resume,
+};
+
+static int __init init_atmel(void)
 {
-        u8 version[4];
         int rc = 0;
         int lo, hi;
 
-        if (pci_enable_device(pci_dev))
-                return -EIO;
+        driver_register(&atml_drv);
 
         lo = tpm_read_index(TPM_ADDR, TPM_ATMEL_BASE_ADDR_LO);
         hi = tpm_read_index(TPM_ADDR, TPM_ATMEL_BASE_ADDR_HI);
 
         tpm_atmel.base = (hi<<8)|lo;
-        dev_dbg( &pci_dev->dev, "Operating with base: 0x%x\n", tpm_atmel.base);
 
         /* verify that it is an Atmel part */
         if (tpm_read_index(TPM_ADDR, 4) != 'A' || tpm_read_index(TPM_ADDR, 5) != 'T'
             || tpm_read_index(TPM_ADDR, 6) != 'M' || tpm_read_index(TPM_ADDR, 7) != 'L') {
-                rc = -ENODEV;
-                goto out_err;
+                return -ENODEV;
         }
 
-        /* query chip for its version number */
-        if ((version[0] = tpm_read_index(TPM_ADDR, 0x00)) != 0xFF) {
-                version[1] = tpm_read_index(TPM_ADDR, 0x01);
-                version[2] = tpm_read_index(TPM_ADDR, 0x02);
-                version[3] = tpm_read_index(TPM_ADDR, 0x03);
-        } else {
-                dev_info(&pci_dev->dev, "version query failed\n");
-                rc = -ENODEV;
-                goto out_err;
+        /* verify chip version number is 1.1 */
+        if (    (tpm_read_index(TPM_ADDR, 0x00) != 0x01) ||
+                (tpm_read_index(TPM_ADDR, 0x01) != 0x01 ))
+                return -ENODEV;
+
+        pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
+        if ( !pdev )
+                return -ENOMEM;
+
+        pdev->name = "tpm_atmel0";
+        pdev->id = -1;
+        pdev->num_resources = 0;
+        pdev->dev.release = tpm_atml_remove;
+        pdev->dev.driver = &atml_drv;
+
+        if ((rc = platform_device_register(pdev)) < 0) {
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
         }
 
-        if ((rc = tpm_register_hardware(pci_dev, &tpm_atmel)) < 0)
-                goto out_err;
+        if (request_region(tpm_atmel.base, 2, "tpm_atmel0") == NULL ) {
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return -EBUSY;
+        }
 
-        dev_info(&pci_dev->dev,
-                 "Atmel TPM version %d.%d.%d.%d\n", version[0], version[1],
-                 version[2], version[3]);
+        if ((rc = tpm_register_hardware(&pdev->dev, &tpm_atmel)) < 0) {
+                release_region(tpm_atmel.base, 2);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
 
+        dev_info(&pdev->dev, "Atmel TPM 1.1, Base Address: 0x%x\n",
+                        tpm_atmel.base);
         return 0;
-out_err:
-        pci_disable_device(pci_dev);
-        return rc;
-}
-
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
-        {PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6LPC)},
-        {0,}
-};
-
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
-
-static struct pci_driver atmel_pci_driver = {
-        .name = "tpm_atmel",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_atml_init,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
-};
-
-static int __init init_atmel(void)
-{
-        return pci_register_driver(&atmel_pci_driver);
 }
 
 static void __exit cleanup_atmel(void)
 {
-        pci_unregister_driver(&atmel_pci_driver);
+        if (pdev) {
+                tpm_atml_remove(&pdev->dev);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+        }
+
+        driver_unregister(&atml_drv);
 }
 
 module_init(init_atmel);
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index 939e51e119e6..8198dbb7370f 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -5,6 +5,7 @@
  * Specifications at www.trustedcomputinggroup.org
  *
  * Copyright (C) 2005, Marcel Selhorst <selhorst@crypto.rub.de>
+ * Sirrix AG - security technologies, http://www.sirrix.com and
  * Applied Data Security Group, Ruhr-University Bochum, Germany
  * Project-Homepage: http://www.prosec.rub.de/tpm
  *
@@ -29,9 +30,10 @@
 #define TPM_INFINEON_DEV_VEN_VALUE      0x15D1
 
 /* These values will be filled after PnP-call */
-static int TPM_INF_DATA = 0;
-static int TPM_INF_ADDR = 0;
-static int pnp_registered = 0;
+static int TPM_INF_DATA;
+static int TPM_INF_ADDR;
+static int TPM_INF_BASE;
+static int TPM_INF_PORT_LEN;
 
 /* TPM header definitions */
 enum infineon_tpm_header {
@@ -143,11 +145,9 @@ static int wait(struct tpm_chip *chip, int wait_for_bit)
         }
         if (i == TPM_MAX_TRIES) {       /* timeout occurs */
                 if (wait_for_bit == STAT_XFE)
-                        dev_err(&chip->pci_dev->dev,
-                                "Timeout in wait(STAT_XFE)\n");
+                        dev_err(chip->dev, "Timeout in wait(STAT_XFE)\n");
                 if (wait_for_bit == STAT_RDA)
-                        dev_err(&chip->pci_dev->dev,
-                                "Timeout in wait(STAT_RDA)\n");
+                        dev_err(chip->dev, "Timeout in wait(STAT_RDA)\n");
                 return -EIO;
         }
         return 0;
@@ -170,7 +170,7 @@ static void wait_and_send(struct tpm_chip *chip, u8 sendbyte)
 static void tpm_wtx(struct tpm_chip *chip)
 {
         number_of_wtx++;
-        dev_info(&chip->pci_dev->dev, "Granting WTX (%02d / %02d)\n",
+        dev_info(chip->dev, "Granting WTX (%02d / %02d)\n",
                  number_of_wtx, TPM_MAX_WTX_PACKAGES);
         wait_and_send(chip, TPM_VL_VER);
         wait_and_send(chip, TPM_CTRL_WTX);
@@ -181,7 +181,7 @@ static void tpm_wtx(struct tpm_chip *chip)
 
 static void tpm_wtx_abort(struct tpm_chip *chip)
 {
-        dev_info(&chip->pci_dev->dev, "Aborting WTX\n");
+        dev_info(chip->dev, "Aborting WTX\n");
         wait_and_send(chip, TPM_VL_VER);
         wait_and_send(chip, TPM_CTRL_WTX_ABORT);
         wait_and_send(chip, 0x00);
@@ -206,7 +206,7 @@ recv_begin:
         }
 
         if (buf[0] != TPM_VL_VER) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "Wrong transport protocol implementation!\n");
                 return -EIO;
         }
@@ -221,8 +221,7 @@ recv_begin:
                 }
 
                 if ((size == 0x6D00) && (buf[1] == 0x80)) {
-                        dev_err(&chip->pci_dev->dev,
-                                "Error handling on vendor layer!\n");
+                        dev_err(chip->dev, "Error handling on vendor layer!\n");
                         return -EIO;
                 }
 
@@ -234,7 +233,7 @@ recv_begin:
         }
 
         if (buf[1] == TPM_CTRL_WTX) {
-                dev_info(&chip->pci_dev->dev, "WTX-package received\n");
+                dev_info(chip->dev, "WTX-package received\n");
                 if (number_of_wtx < TPM_MAX_WTX_PACKAGES) {
                         tpm_wtx(chip);
                         goto recv_begin;
@@ -245,14 +244,14 @@ recv_begin:
         }
 
         if (buf[1] == TPM_CTRL_WTX_ABORT_ACK) {
-                dev_info(&chip->pci_dev->dev, "WTX-abort acknowledged\n");
+                dev_info(chip->dev, "WTX-abort acknowledged\n");
                 return size;
         }
 
         if (buf[1] == TPM_CTRL_ERROR) {
-                dev_err(&chip->pci_dev->dev, "ERROR-package received:\n");
+                dev_err(chip->dev, "ERROR-package received:\n");
                 if (buf[4] == TPM_INF_NAK)
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "-> Negative acknowledgement"
                                 " - retransmit command!\n");
                 return -EIO;
@@ -271,7 +270,7 @@ static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count)
 
         ret = empty_fifo(chip, 1);
         if (ret) {
-                dev_err(&chip->pci_dev->dev, "Timeout while clearing FIFO\n");
+                dev_err(chip->dev, "Timeout while clearing FIFO\n");
                 return -EIO;
         }
 
@@ -316,6 +315,11 @@ static void tpm_inf_cancel(struct tpm_chip *chip)
          */
 }
 
+static u8 tpm_inf_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + STAT);
+}
+
 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
@@ -344,6 +348,7 @@ static struct tpm_vendor_specific tpm_inf = {
         .recv = tpm_inf_recv,
         .send = tpm_inf_send,
         .cancel = tpm_inf_cancel,
+        .status = tpm_inf_status,
         .req_complete_mask = 0,
         .req_complete_val = 0,
         .attr_group = &inf_attr_grp,
@@ -356,30 +361,11 @@ static const struct pnp_device_id tpm_pnp_tbl[] = {
         {"IFX0102", 0},
         {"", 0}
 };
+
 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
 
 static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
-                                        const struct pnp_device_id *dev_id)
-{
-        if (pnp_port_valid(dev, 0)) {
-                TPM_INF_ADDR = (pnp_port_start(dev, 0) & 0xff);
-                TPM_INF_DATA = ((TPM_INF_ADDR + 1) & 0xff);
-                tpm_inf.base = pnp_port_start(dev, 1);
-                dev_info(&dev->dev, "Found %s with ID %s\n",
-                dev->name, dev_id->id);
-                return 0;
-        }
-        return -ENODEV;
-}
-
-static struct pnp_driver tpm_inf_pnp = {
-        .name = "tpm_inf_pnp",
-        .id_table = tpm_pnp_tbl,
-        .probe = tpm_inf_pnp_probe,
-};
-
-static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
-                                   const struct pci_device_id *pci_id)
+                                       const struct pnp_device_id *dev_id)
 {
         int rc = 0;
         u8 iol, ioh;
@@ -388,30 +374,28 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
         int productid[2];
         char chipname[20];
 
-        rc = pci_enable_device(pci_dev);
-        if (rc)
-                return rc;
-
-        dev_info(&pci_dev->dev, "LPC-bus found at 0x%x\n", pci_id->device);
-
-        /* read IO-ports from PnP */
-        rc = pnp_register_driver(&tpm_inf_pnp);
-        if (rc < 0) {
-                dev_err(&pci_dev->dev,
-                        "Error %x from pnp_register_driver!\n",rc);
-                goto error2;
-        }
-        if (!rc) {
-                dev_info(&pci_dev->dev, "No Infineon TPM found!\n");
-                goto error;
+        /* read IO-ports through PnP */
+        if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
+            !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
+                TPM_INF_ADDR = pnp_port_start(dev, 0);
+                TPM_INF_DATA = (TPM_INF_ADDR + 1);
+                TPM_INF_BASE = pnp_port_start(dev, 1);
+                TPM_INF_PORT_LEN = pnp_port_len(dev, 1);
+                if (!TPM_INF_PORT_LEN)
+                        return -EINVAL;
+                dev_info(&dev->dev, "Found %s with ID %s\n",
+                         dev->name, dev_id->id);
+                if (!((TPM_INF_BASE >> 8) & 0xff))
+                        return -EINVAL;
+                /* publish my base address and request region */
+                tpm_inf.base = TPM_INF_BASE;
+                if (request_region
+                    (tpm_inf.base, TPM_INF_PORT_LEN, "tpm_infineon0") == NULL) {
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -EINVAL;
+                }
         } else {
-                pnp_registered = 1;
-        }
-
-        /* Make sure, we have received valid config ports */
-        if (!TPM_INF_ADDR) {
-                dev_err(&pci_dev->dev, "No valid IO-ports received!\n");
-                goto error;
+                return -EINVAL;
         }
 
         /* query chip for its vendor, its version number a.s.o. */
@@ -443,10 +427,6 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
 
         if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) {
 
-                if (tpm_inf.base == 0) {
-                        dev_err(&pci_dev->dev, "No IO-ports found!\n");
-                        goto error;
-                }
                 /* configure TPM with IO-ports */
                 outb(IOLIMH, TPM_INF_ADDR);
                 outb(((tpm_inf.base >> 8) & 0xff), TPM_INF_DATA);
@@ -460,10 +440,11 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                 iol = inb(TPM_INF_DATA);
 
                 if ((ioh << 8 | iol) != tpm_inf.base) {
-                        dev_err(&pci_dev->dev,
+                        dev_err(&dev->dev,
                                 "Could not set IO-ports to %04x\n",
                                 tpm_inf.base);
-                        goto error;
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -EIO;
                 }
 
                 /* activate register */
@@ -475,7 +456,7 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                 outb(RESET_LP_IRQC_DISABLE, tpm_inf.base + CMD);
 
                 /* Finally, we're done, print some infos */
-                dev_info(&pci_dev->dev, "TPM found: "
+                dev_info(&dev->dev, "TPM found: "
                          "config base 0x%x, "
                          "io base 0x%x, "
                          "chip version %02x%02x, "
@@ -483,59 +464,53 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                          "product id %02x%02x"
                          "%s\n",
                          TPM_INF_ADDR,
-                         tpm_inf.base,
+                         TPM_INF_BASE,
                          version[0], version[1],
                          vendorid[0], vendorid[1],
                          productid[0], productid[1], chipname);
 
-                rc = tpm_register_hardware(pci_dev, &tpm_inf);
-                if (rc < 0)
-                        goto error;
+                rc = tpm_register_hardware(&dev->dev, &tpm_inf);
+                if (rc < 0) {
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -ENODEV;
+                }
                 return 0;
         } else {
-                dev_info(&pci_dev->dev, "No Infineon TPM found!\n");
-error:
-                pnp_unregister_driver(&tpm_inf_pnp);
-error2:
-                pci_disable_device(pci_dev);
-                pnp_registered = 0;
+                dev_info(&dev->dev, "No Infineon TPM found!\n");
                 return -ENODEV;
         }
 }
 
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_2)},
-        {0,}
-};
+static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
+{
+        struct tpm_chip *chip = pnp_get_drvdata(dev);
 
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
+        if (chip) {
+                release_region(chip->vendor->base, TPM_INF_PORT_LEN);
+                tpm_remove_hardware(chip->dev);
+        }
+}
 
-static struct pci_driver inf_pci_driver = {
-        .name = "tpm_inf",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_inf_probe,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static struct pnp_driver tpm_inf_pnp = {
+        .name = "tpm_inf_pnp",
+        .driver = {
+                .owner = THIS_MODULE,
+                .suspend = tpm_pm_suspend,
+                .resume = tpm_pm_resume,
+        },
+        .id_table = tpm_pnp_tbl,
+        .probe = tpm_inf_pnp_probe,
+        .remove = tpm_inf_pnp_remove,
 };
 
 static int __init init_inf(void)
 {
-        return pci_register_driver(&inf_pci_driver);
+        return pnp_register_driver(&tpm_inf_pnp);
 }
 
 static void __exit cleanup_inf(void)
 {
-        if (pnp_registered)
-                pnp_unregister_driver(&tpm_inf_pnp);
-        pci_unregister_driver(&inf_pci_driver);
+        pnp_unregister_driver(&tpm_inf_pnp);
 }
 
 module_init(init_inf);
@@ -543,5 +518,5 @@ module_exit(cleanup_inf);
 
 MODULE_AUTHOR("Marcel Selhorst <selhorst@crypto.rub.de>");
 MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
-MODULE_VERSION("1.5");
+MODULE_VERSION("1.6");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index b4127348c063..253871b5b1e2 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -111,7 +111,7 @@ static int nsc_wait_for_ready(struct tpm_chip *chip)
         }
         while (time_before(jiffies, stop));
 
-        dev_info(&chip->pci_dev->dev, "wait for ready failed\n");
+        dev_info(chip->dev, "wait for ready failed\n");
         return -EBUSY;
 }
 
@@ -127,12 +127,12 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
                 return -EIO;
 
         if (wait_for_stat(chip, NSC_STATUS_F0, NSC_STATUS_F0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "F0 timeout\n");
+                dev_err(chip->dev, "F0 timeout\n");
                 return -EIO;
         }
         if ((data =
              inb(chip->vendor->base + NSC_DATA)) != NSC_COMMAND_NORMAL) {
-                dev_err(&chip->pci_dev->dev, "not in normal mode (0x%x)\n",
+                dev_err(chip->dev, "not in normal mode (0x%x)\n",
                         data);
                 return -EIO;
         }
@@ -141,7 +141,7 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (p = buffer; p < &buffer[count]; p++) {
                 if (wait_for_stat
                     (chip, NSC_STATUS_OBF, NSC_STATUS_OBF, &data) < 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "OBF timeout (while reading data)\n");
                         return -EIO;
                 }
@@ -152,11 +152,11 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
 
         if ((data & NSC_STATUS_F0) == 0 &&
         (wait_for_stat(chip, NSC_STATUS_F0, NSC_STATUS_F0, &data) < 0)) {
-                dev_err(&chip->pci_dev->dev, "F0 not set\n");
+                dev_err(chip->dev, "F0 not set\n");
                 return -EIO;
         }
         if ((data = inb(chip->vendor->base + NSC_DATA)) != NSC_COMMAND_EOC) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "expected end of command(0x%x)\n", data);
                 return -EIO;
         }
@@ -187,19 +187,19 @@ static int tpm_nsc_send(struct tpm_chip *chip, u8 * buf, size_t count)
                 return -EIO;
 
         if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBF timeout\n");
+                dev_err(chip->dev, "IBF timeout\n");
                 return -EIO;
         }
 
         outb(NSC_COMMAND_NORMAL, chip->vendor->base + NSC_COMMAND);
         if (wait_for_stat(chip, NSC_STATUS_IBR, NSC_STATUS_IBR, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBR timeout\n");
+                dev_err(chip->dev, "IBR timeout\n");
                 return -EIO;
         }
 
         for (i = 0; i < count; i++) {
                 if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "IBF timeout (while writing data)\n");
                         return -EIO;
                 }
@@ -207,7 +207,7 @@ static int tpm_nsc_send(struct tpm_chip *chip, u8 * buf, size_t count)
         }
 
         if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBF timeout\n");
+                dev_err(chip->dev, "IBF timeout\n");
                 return -EIO;
         }
         outb(NSC_COMMAND_EOC, chip->vendor->base + NSC_COMMAND);
@@ -220,6 +220,11 @@ static void tpm_nsc_cancel(struct tpm_chip *chip)
         outb(NSC_COMMAND_CANCEL, chip->vendor->base + NSC_COMMAND);
 }
 
+static u8 tpm_nsc_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + NSC_STATUS);
+}
+
 static struct file_operations nsc_ops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
@@ -239,7 +244,7 @@ static struct attribute * nsc_attrs[] = {
         &dev_attr_pcrs.attr,
         &dev_attr_caps.attr,
         &dev_attr_cancel.attr,
-        0,
+        NULL,
 };
 
 static struct attribute_group nsc_attr_grp = { .attrs = nsc_attrs };
@@ -248,6 +253,7 @@ static struct tpm_vendor_specific tpm_nsc = {
         .recv = tpm_nsc_recv,
         .send = tpm_nsc_send,
         .cancel = tpm_nsc_cancel,
+        .status = tpm_nsc_status,
         .req_complete_mask = NSC_STATUS_OBF,
         .req_complete_val = NSC_STATUS_OBF,
         .req_canceled = NSC_STATUS_RDY,
@@ -255,16 +261,32 @@ static struct tpm_vendor_specific tpm_nsc = {
         .miscdev = { .fops = &nsc_ops, },
 };
 
-static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
-                                  const struct pci_device_id *pci_id)
+static struct platform_device *pdev = NULL;
+
+static void __devexit tpm_nsc_remove(struct device *dev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(dev);
+        if ( chip ) {
+                release_region(chip->vendor->base, 2);
+                tpm_remove_hardware(chip->dev);
+        }
+}
+
+static struct device_driver nsc_drv = {
+        .name = "tpm_nsc",
+        .bus = &platform_bus_type,
+        .owner = THIS_MODULE,
+        .suspend = tpm_pm_suspend,
+        .resume = tpm_pm_resume,
+};
+
+static int __init init_nsc(void)
 {
         int rc = 0;
         int lo, hi;
         int nscAddrBase = TPM_ADDR;
 
-
-        if (pci_enable_device(pci_dev))
-                return -EIO;
+        driver_register(&nsc_drv);
 
         /* select PM channel 1 */
         tpm_write_index(nscAddrBase,NSC_LDN_INDEX, 0x12);
@@ -273,37 +295,71 @@ static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
         if (tpm_read_index(TPM_ADDR, NSC_SID_INDEX) != 0xEF) {
                 nscAddrBase = (tpm_read_index(TPM_SUPERIO_ADDR, 0x2C)<<8)|
                         (tpm_read_index(TPM_SUPERIO_ADDR, 0x2B)&0xFE);
-                if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6) {
-                        rc = -ENODEV;
-                        goto out_err;
-                }
+                if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6)
+                        return -ENODEV;
         }
 
         hi = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_HI);
         lo = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_LO);
         tpm_nsc.base = (hi<<8) | lo;
 
-        dev_dbg(&pci_dev->dev, "NSC TPM detected\n");
-        dev_dbg(&pci_dev->dev,
+        /* enable the DPM module */
+        tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
+
+        pdev = kmalloc(sizeof(struct platform_device), GFP_KERNEL);
+        if ( !pdev )
+                return -ENOMEM;
+
+        memset(pdev, 0, sizeof(struct platform_device));
+
+        pdev->name = "tpm_nscl0";
+        pdev->id = -1;
+        pdev->num_resources = 0;
+        pdev->dev.release = tpm_nsc_remove;
+        pdev->dev.driver = &nsc_drv;
+
+        if ((rc=platform_device_register(pdev)) < 0) {
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
+
+        if (request_region(tpm_nsc.base, 2, "tpm_nsc0") == NULL ) {
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return -EBUSY;
+        }
+
+        if ((rc = tpm_register_hardware(&pdev->dev, &tpm_nsc)) < 0) {
+                release_region(tpm_nsc.base, 2);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
+
+        dev_dbg(&pdev->dev, "NSC TPM detected\n");
+        dev_dbg(&pdev->dev,
                 "NSC LDN 0x%x, SID 0x%x, SRID 0x%x\n",
                 tpm_read_index(nscAddrBase,0x07), tpm_read_index(nscAddrBase,0x20),
                 tpm_read_index(nscAddrBase,0x27));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC SIOCF1 0x%x SIOCF5 0x%x SIOCF6 0x%x SIOCF8 0x%x\n",
                 tpm_read_index(nscAddrBase,0x21), tpm_read_index(nscAddrBase,0x25),
                 tpm_read_index(nscAddrBase,0x26), tpm_read_index(nscAddrBase,0x28));
-        dev_dbg(&pci_dev->dev, "NSC IO Base0 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IO Base0 0x%x\n",
                 (tpm_read_index(nscAddrBase,0x60) << 8) | tpm_read_index(nscAddrBase,0x61));
-        dev_dbg(&pci_dev->dev, "NSC IO Base1 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IO Base1 0x%x\n",
                 (tpm_read_index(nscAddrBase,0x62) << 8) | tpm_read_index(nscAddrBase,0x63));
-        dev_dbg(&pci_dev->dev, "NSC Interrupt number and wakeup 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC Interrupt number and wakeup 0x%x\n",
                 tpm_read_index(nscAddrBase,0x70));
-        dev_dbg(&pci_dev->dev, "NSC IRQ type select 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IRQ type select 0x%x\n",
                 tpm_read_index(nscAddrBase,0x71));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC DMA channel select0 0x%x, select1 0x%x\n",
                 tpm_read_index(nscAddrBase,0x74), tpm_read_index(nscAddrBase,0x75));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC Config "
                 "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                 tpm_read_index(nscAddrBase,0xF0), tpm_read_index(nscAddrBase,0xF1),
@@ -312,55 +368,23 @@ static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
                 tpm_read_index(nscAddrBase,0xF6), tpm_read_index(nscAddrBase,0xF7),
                 tpm_read_index(nscAddrBase,0xF8), tpm_read_index(nscAddrBase,0xF9));
 
-        dev_info(&pci_dev->dev,
+        dev_info(&pdev->dev,
                  "NSC TPM revision %d\n",
                  tpm_read_index(nscAddrBase, 0x27) & 0x1F);
 
-        /* enable the DPM module */
-        tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
-
-        if ((rc = tpm_register_hardware(pci_dev, &tpm_nsc)) < 0)
-                goto out_err;
-
         return 0;
-
-out_err:
-        pci_disable_device(pci_dev);
-        return rc;
-}
-
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
-        {0,}
-};
-
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
-
-static struct pci_driver nsc_pci_driver = {
-        .name = "tpm_nsc",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_nsc_init,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
-};
-
-static int __init init_nsc(void)
-{
-        return pci_register_driver(&nsc_pci_driver);
 }
 
 static void __exit cleanup_nsc(void)
 {
-        pci_unregister_driver(&nsc_pci_driver);
+        if (pdev) {
+                tpm_nsc_remove(&pdev->dev);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+        }
+
+        driver_unregister(&nsc_drv);
 }
 
 module_init(init_nsc);
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index f5649a337743..c586bfa852ee 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -809,7 +809,7 @@ static void do_tty_hangup(void *data)
         check_tty_count(tty, "do_tty_hangup");
         file_list_lock();
         /* This breaks for file handles being sent over AF_UNIX sockets ? */
-        list_for_each_entry(filp, &tty->tty_files, f_list) {
+        list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
                 if (filp->f_op->write == redirected_tty_write)
                         cons_filp = filp;
                 if (filp->f_op->write != tty_write)
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index a5e104f428f8..51abd3defc1c 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -993,13 +993,16 @@ static struct vio_device_id viotape_device_table[] __devinitdata = {
         { "viotape", "" },
         { "", "" }
 };
-
 MODULE_DEVICE_TABLE(vio, viotape_device_table);
+
 static struct vio_driver viotape_driver = {
-        .name = "viotape",
         .id_table = viotape_device_table,
         .probe = viotape_probe,
-        .remove = viotape_remove
+        .remove = viotape_remove,
+        .driver = {
+                .name = "viotape",
+                .owner = THIS_MODULE,
+        }
 };
 
 
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 1d44f69e1fda..003dda147cd0 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -192,6 +192,9 @@ do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
         int i, j, k;
         int ret;
 
+        if (!capable(CAP_SYS_TTY_CONFIG))
+                return -EPERM;
+
         kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
         if (!kbs) {
                 ret = -ENOMEM;
diff --git a/drivers/char/watchdog/cpu5wdt.c b/drivers/char/watchdog/cpu5wdt.c
index 2865dac0a813..e75045fe2641 100644
--- a/drivers/char/watchdog/cpu5wdt.c
+++ b/drivers/char/watchdog/cpu5wdt.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/timer.h>
+#include <linux/jiffies.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/char/watchdog/mixcomwd.c b/drivers/char/watchdog/mixcomwd.c
index 7fc2188386d9..d8dede575402 100644
--- a/drivers/char/watchdog/mixcomwd.c
+++ b/drivers/char/watchdog/mixcomwd.c
@@ -45,6 +45,8 @@
 #include <linux/fs.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/timer.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
diff --git a/drivers/char/watchdog/pcwd.c b/drivers/char/watchdog/pcwd.c
index 427ad51b7a35..37c9e13ad3ac 100644
--- a/drivers/char/watchdog/pcwd.c
+++ b/drivers/char/watchdog/pcwd.c
@@ -66,7 +66,7 @@
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/reboot.h>
-
+#include <linux/sched.h>        /* TASK_INTERRUPTIBLE, set_current_state() and friends */
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
diff --git a/drivers/char/watchdog/pcwd_pci.c b/drivers/char/watchdog/pcwd_pci.c
index 0b8e493be045..5308e5c8f29a 100644
--- a/drivers/char/watchdog/pcwd_pci.c
+++ b/drivers/char/watchdog/pcwd_pci.c
@@ -753,6 +753,7 @@ static struct pci_device_id pcipcwd_pci_tbl[] = {
 MODULE_DEVICE_TABLE(pci, pcipcwd_pci_tbl);
 
 static struct pci_driver pcipcwd_driver = {
+        .owner          = THIS_MODULE,
         .name           = WATCHDOG_NAME,
         .id_table       = pcipcwd_pci_tbl,
         .probe          = pcipcwd_card_init,
diff --git a/drivers/char/watchdog/sc520_wdt.c b/drivers/char/watchdog/sc520_wdt.c
index 72501be79b0c..4ee9974ad8cb 100644
--- a/drivers/char/watchdog/sc520_wdt.c
+++ b/drivers/char/watchdog/sc520_wdt.c
@@ -63,6 +63,7 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
diff --git a/drivers/char/watchdog/softdog.c b/drivers/char/watchdog/softdog.c
index 20e5eb8667f2..a91edaf3a350 100644
--- a/drivers/char/watchdog/softdog.c
+++ b/drivers/char/watchdog/softdog.c
@@ -47,6 +47,8 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
+
 #include <asm/uaccess.h>
 
 #define PFX "SoftDog: "
diff --git a/drivers/char/watchdog/wdt_pci.c b/drivers/char/watchdog/wdt_pci.c
index 4b3311993d48..dc9370f6c348 100644
--- a/drivers/char/watchdog/wdt_pci.c
+++ b/drivers/char/watchdog/wdt_pci.c
@@ -711,6 +711,7 @@ MODULE_DEVICE_TABLE(pci, wdtpci_pci_tbl);
 
 
 static struct pci_driver wdtpci_driver = {
+        .owner          = THIS_MODULE,
         .name           = "wdt_pci",
         .id_table       = wdtpci_pci_tbl,
         .probe          = wdtpci_init_one,
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 109d62ccf651..6c6121b85a54 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -4,6 +4,9 @@
  *  Copyright (C) 2001 Russell King
  *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
  *
+ *  Oct 2005 - Ashok Raj <ashok.raj@intel.com>
+ *                      Added handling for CPU hotplug
+ *
  * 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.
@@ -36,13 +39,6 @@ static struct cpufreq_policy	*cpufreq_cpu_data[NR_CPUS];
 static DEFINE_SPINLOCK(cpufreq_driver_lock);
 
 
-/* we keep a copy of all ->add'ed CPU's struct sys_device here;
- * as it is only accessed in ->add and ->remove, no lock or reference
- * count is necessary.
- */
-static struct sys_device        *cpu_sys_devices[NR_CPUS];
-
-
 /* internal prototypes */
 static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
 static void handle_update(void *data);
@@ -574,6 +570,9 @@ static int cpufreq_add_dev (struct sys_device * sys_dev)
         unsigned long flags;
         unsigned int j;
 
+        if (cpu_is_offline(cpu))
+                return 0;
+
         cpufreq_debug_disable_ratelimit();
         dprintk("adding CPU %u\n", cpu);
 
@@ -582,7 +581,6 @@ static int cpufreq_add_dev (struct sys_device * sys_dev)
          * CPU because it is in the same boat. */
         policy = cpufreq_cpu_get(cpu);
         if (unlikely(policy)) {
-                cpu_sys_devices[cpu] = sys_dev;
                 dprintk("CPU already managed, adding link\n");
                 sysfs_create_link(&sys_dev->kobj, &policy->kobj, "cpufreq");
                 cpufreq_debug_enable_ratelimit();
@@ -657,7 +655,6 @@ static int cpufreq_add_dev (struct sys_device * sys_dev)
         }
 
         module_put(cpufreq_driver->owner);
-        cpu_sys_devices[cpu] = sys_dev;
         dprintk("initialization complete\n");
         cpufreq_debug_enable_ratelimit();
         
@@ -682,7 +679,7 @@ err_out:
 
 nomem_out:
         module_put(cpufreq_driver->owner);
- module_out:
+module_out:
         cpufreq_debug_enable_ratelimit();
         return ret;
 }
@@ -698,6 +695,7 @@ static int cpufreq_remove_dev (struct sys_device * sys_dev)
         unsigned int cpu = sys_dev->id;
         unsigned long flags;
         struct cpufreq_policy *data;
+        struct sys_device *cpu_sys_dev;
 #ifdef CONFIG_SMP
         unsigned int j;
 #endif
@@ -710,7 +708,6 @@ static int cpufreq_remove_dev (struct sys_device * sys_dev)
 
         if (!data) {
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
-                cpu_sys_devices[cpu] = NULL;
                 cpufreq_debug_enable_ratelimit();
                 return -EINVAL;
         }
@@ -725,14 +722,12 @@ static int cpufreq_remove_dev (struct sys_device * sys_dev)
                 dprintk("removing link\n");
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
                 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
-                cpu_sys_devices[cpu] = NULL;
                 cpufreq_cpu_put(data);
                 cpufreq_debug_enable_ratelimit();
                 return 0;
         }
 #endif
 
-        cpu_sys_devices[cpu] = NULL;
 
         if (!kobject_get(&data->kobj)) {
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
@@ -761,7 +756,8 @@ static int cpufreq_remove_dev (struct sys_device * sys_dev)
                         if (j == cpu)
                                 continue;
                         dprintk("removing link for cpu %u\n", j);
-                        sysfs_remove_link(&cpu_sys_devices[j]->kobj, "cpufreq");
+                        cpu_sys_dev = get_cpu_sysdev(j);
+                        sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
                         cpufreq_cpu_put(data);
                 }
         }
@@ -772,7 +768,6 @@ static int cpufreq_remove_dev (struct sys_device * sys_dev)
         down(&data->lock);
         if (cpufreq_driver->target)
                 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
-        cpufreq_driver->target = NULL;
         up(&data->lock);
 
         kobject_unregister(&data->kobj);
@@ -1119,17 +1114,30 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy,
                             unsigned int relation)
 {
         int retval = -EINVAL;
-        lock_cpu_hotplug();
+
+        /*
+         * Converted the lock_cpu_hotplug to preempt_disable()
+         * and preempt_enable(). This is a bit kludgy and relies on how cpu
+         * hotplug works. All we need is a guarantee that cpu hotplug won't make
+         * progress on any cpu. Once we do preempt_disable(), this would ensure
+         * that hotplug threads don't get onto this cpu, thereby delaying
+         * the cpu remove process.
+         *
+         * We removed the lock_cpu_hotplug since we need to call this function
+         * via cpu hotplug callbacks, which result in locking the cpu hotplug
+         * thread itself. Agree this is not very clean, cpufreq community
+         * could improve this if required. - Ashok Raj <ashok.raj@intel.com>
+         */
+        preempt_disable();
         dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
                 target_freq, relation);
         if (cpu_online(policy->cpu) && cpufreq_driver->target)
                 retval = cpufreq_driver->target(policy, target_freq, relation);
-        unlock_cpu_hotplug();
+        preempt_enable();
         return retval;
 }
 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
 
-
 int cpufreq_driver_target(struct cpufreq_policy *policy,
                           unsigned int target_freq,
                           unsigned int relation)
@@ -1416,6 +1424,45 @@ int cpufreq_update_policy(unsigned int cpu)
 }
 EXPORT_SYMBOL(cpufreq_update_policy);
 
+static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
+                                        unsigned long action, void *hcpu)
+{
+        unsigned int cpu = (unsigned long)hcpu;
+        struct cpufreq_policy *policy;
+        struct sys_device *sys_dev;
+
+        sys_dev = get_cpu_sysdev(cpu);
+
+        if (sys_dev) {
+                switch (action) {
+                case CPU_ONLINE:
+                        cpufreq_add_dev(sys_dev);
+                        break;
+                case CPU_DOWN_PREPARE:
+                        /*
+                         * We attempt to put this cpu in lowest frequency
+                         * possible before going down. This will permit
+                         * hardware-managed P-State to switch other related
+                         * threads to min or higher speeds if possible.
+                         */
+                        policy = cpufreq_cpu_data[cpu];
+                        if (policy) {
+                                cpufreq_driver_target(policy, policy->min,
+                                                CPUFREQ_RELATION_H);
+                        }
+                        break;
+                case CPU_DEAD:
+                        cpufreq_remove_dev(sys_dev);
+                        break;
+                }
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block cpufreq_cpu_notifier =
+{
+    .notifier_call = cpufreq_cpu_callback,
+};
 
 /*********************************************************************
  *               REGISTER / UNREGISTER CPUFREQ DRIVER                *
@@ -1476,6 +1523,7 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
         }
 
         if (!ret) {
+                register_cpu_notifier(&cpufreq_cpu_notifier);
                 dprintk("driver %s up and running\n", driver_data->name);
                 cpufreq_debug_enable_ratelimit();
         }
@@ -1507,6 +1555,7 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver)
         dprintk("unregistering driver %s\n", driver->name);
 
         sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
+        unregister_cpu_notifier(&cpufreq_cpu_notifier);
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
         cpufreq_driver = NULL;
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index 741b6b191e6a..3597f25d5efa 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -19,6 +19,7 @@
 #include <linux/percpu.h>
 #include <linux/kobject.h>
 #include <linux/spinlock.h>
+#include <linux/notifier.h>
 #include <asm/cputime.h>
 
 static spinlock_t cpufreq_stats_lock;
@@ -298,6 +299,27 @@ cpufreq_stat_notifier_trans (struct notifier_block *nb, unsigned long val,
         return 0;
 }
 
+static int __cpuinit cpufreq_stat_cpu_callback(struct notifier_block *nfb,
+                                        unsigned long action, void *hcpu)
+{
+        unsigned int cpu = (unsigned long)hcpu;
+
+        switch (action) {
+        case CPU_ONLINE:
+                cpufreq_update_policy(cpu);
+                break;
+        case CPU_DEAD:
+                cpufreq_stats_free_table(cpu);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block cpufreq_stat_cpu_notifier =
+{
+        .notifier_call = cpufreq_stat_cpu_callback,
+};
+
 static struct notifier_block notifier_policy_block = {
         .notifier_call = cpufreq_stat_notifier_policy
 };
@@ -311,6 +333,7 @@ __init cpufreq_stats_init(void)
 {
         int ret;
         unsigned int cpu;
+
         spin_lock_init(&cpufreq_stats_lock);
         if ((ret = cpufreq_register_notifier(&notifier_policy_block,
                                 CPUFREQ_POLICY_NOTIFIER)))
@@ -323,20 +346,31 @@ __init cpufreq_stats_init(void)
                 return ret;
         }
 
-        for_each_cpu(cpu)
-                cpufreq_update_policy(cpu);
+        register_cpu_notifier(&cpufreq_stat_cpu_notifier);
+        lock_cpu_hotplug();
+        for_each_online_cpu(cpu) {
+                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, CPU_ONLINE,
+                        (void *)(long)cpu);
+        }
+        unlock_cpu_hotplug();
         return 0;
 }
 static void
 __exit cpufreq_stats_exit(void)
 {
         unsigned int cpu;
+
         cpufreq_unregister_notifier(&notifier_policy_block,
                         CPUFREQ_POLICY_NOTIFIER);
         cpufreq_unregister_notifier(&notifier_trans_block,
                         CPUFREQ_TRANSITION_NOTIFIER);
-        for_each_cpu(cpu)
-                cpufreq_stats_free_table(cpu);
+        unregister_cpu_notifier(&cpufreq_stat_cpu_notifier);
+        lock_cpu_hotplug();
+        for_each_online_cpu(cpu) {
+                cpufreq_stat_cpu_callback(&cpufreq_stat_cpu_notifier, CPU_DEAD,
+                        (void *)(long)cpu);
+        }
+        unlock_cpu_hotplug();
 }
 
 MODULE_AUTHOR ("Zou Nan hai <nanhai.zou@intel.com>");
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index 094835cce321..4263935443cc 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -2,7 +2,7 @@ menu "Hardware crypto devices"
 
 config CRYPTO_DEV_PADLOCK
         tristate "Support for VIA PadLock ACE"
-        depends on CRYPTO && X86 && !X86_64
+        depends on CRYPTO && X86_32
         help
           Some VIA processors come with an integrated crypto engine
           (so called VIA PadLock ACE, Advanced Cryptography Engine)
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 327b58e64875..b6815c6c29a2 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -70,8 +70,7 @@ config DELL_RBU
 
 config DCDBAS
         tristate "Dell Systems Management Base Driver"
-        depends on X86 || X86_64
-        default m
+        depends on X86
         help
           The Dell Systems Management Base Driver provides a sysfs interface
           for systems management software to perform System Management
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 1cadd2c3cadd..a737886e39d1 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -778,6 +778,35 @@ config BLK_DEV_IDE_PMAC_BLINK
           This option enables the use of the sleep LED as a hard drive
           activity LED.
 
+config BLK_DEV_IDE_AU1XXX
+       bool "IDE for AMD Alchemy Au1200"
+       depends on SOC_AU1200
+choice
+       prompt "IDE Mode for AMD Alchemy Au1200"
+       default CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA
+       depends on SOC_AU1200 && BLK_DEV_IDE_AU1XXX
+
+config BLK_DEV_IDE_AU1XXX_PIO_DBDMA
+       bool "PIO+DbDMA IDE for AMD Alchemy Au1200"
+
+config BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+       bool "MDMA2+DbDMA IDE for AMD Alchemy Au1200"
+       depends on SOC_AU1200 && BLK_DEV_IDE_AU1XXX
+endchoice
+
+config BLK_DEV_IDE_AU1XXX_BURSTABLE_ON
+        bool "Enable burstable Mode on DbDMA"
+        default false
+        depends BLK_DEV_IDE_AU1XXX
+        help
+          This option enable the burstable Flag on DbDMA controller
+          (cf. "AMD Alchemy 'Au1200' Processor Data Book - PRELIMINARY").
+
+config BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ
+       int "Maximum transfer size (KB) per request (up to 128)"
+       default "128"
+       depends BLK_DEV_IDE_AU1XXX
+
 config IDE_ARM
         def_bool ARM && (ARCH_A5K || ARCH_CLPS7500 || ARCH_RPC || ARCH_SHARK)
 
@@ -1013,7 +1042,7 @@ config BLK_DEV_UMC8672
 endif
 
 config BLK_DEV_IDEDMA
-        def_bool BLK_DEV_IDEDMA_PCI || BLK_DEV_IDEDMA_PMAC || BLK_DEV_IDEDMA_ICS
+        def_bool BLK_DEV_IDEDMA_PCI || BLK_DEV_IDEDMA_PMAC || BLK_DEV_IDEDMA_ICS || BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
 
 config IDEDMA_IVB
         bool "IGNORE word93 Validation BITS"
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 74af7e074868..8b9d85526596 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -2211,13 +2211,12 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
 
         if (toc == NULL) {
                 /* Try to allocate space. */
-                toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
-                                                    GFP_KERNEL);
-                info->toc = toc;
+                toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
                 if (toc == NULL) {
                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
                         return -ENOMEM;
                 }
+                info->toc = toc;
         }
 
         /* Check to see if the existing data is still valid.
@@ -2240,7 +2239,8 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
         /* First read just the header, so we know how long the TOC is. */
         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
                                     sizeof(struct atapi_toc_header), sense);
-        if (stat) return stat;
+        if (stat)
+                return stat;
 
 #if ! STANDARD_ATAPI
         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
@@ -2324,7 +2324,8 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
                 /* Read the multisession information. */
                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
                                            sizeof(ms_tmp), sense);
-                if (stat) return stat;
+                if (stat)
+                        return stat;
 
                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
         } else {
@@ -2460,7 +2461,7 @@ static int ide_cdrom_packet(struct cdrom_device_info *cdi,
                             struct packet_command *cgc)
 {
         struct request req;
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
 
         if (cgc->timeout <= 0)
                 cgc->timeout = ATAPI_WAIT_PC;
@@ -2537,7 +2538,7 @@ int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
                            unsigned int cmd, void *arg)
                            
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         struct cdrom_info *info = drive->driver_data;
         int stat;
 
@@ -2548,7 +2549,7 @@ int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
          */
         case CDROMPLAYTRKIND: {
                 unsigned long lba_start, lba_end;
-                struct cdrom_ti *ti = (struct cdrom_ti *)arg;
+                struct cdrom_ti *ti = arg;
                 struct atapi_toc_entry *first_toc, *last_toc;
 
                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
@@ -2571,12 +2572,13 @@ int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
         }
 
         case CDROMREADTOCHDR: {
-                struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
+                struct cdrom_tochdr *tochdr = arg;
                 struct atapi_toc *toc;
 
                 /* Make sure our saved TOC is valid. */
                 stat = cdrom_read_toc(drive, NULL);
-                if (stat) return stat;
+                if (stat)
+                        return stat;
 
                 toc = info->toc;
                 tochdr->cdth_trk0 = toc->hdr.first_track;
@@ -2586,11 +2588,12 @@ int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
         }
 
         case CDROMREADTOCENTRY: {
-                struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
+                struct cdrom_tocentry *tocentry = arg;
                 struct atapi_toc_entry *toce;
 
                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
-                if (stat) return stat;
+                if (stat)
+                        return stat;
 
                 tocentry->cdte_ctrl = toce->control;
                 tocentry->cdte_adr  = toce->adr;
@@ -2613,7 +2616,7 @@ int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
 static
 int ide_cdrom_reset (struct cdrom_device_info *cdi)
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         struct request_sense sense;
         struct request req;
         int ret;
@@ -2636,12 +2639,13 @@ int ide_cdrom_reset (struct cdrom_device_info *cdi)
 static
 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         struct request_sense sense;
 
         if (position) {
                 int stat = cdrom_lockdoor(drive, 0, &sense);
-                if (stat) return stat;
+                if (stat)
+                        return stat;
         }
 
         return cdrom_eject(drive, !position, &sense);
@@ -2650,7 +2654,7 @@ int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
 static
 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         return cdrom_lockdoor(drive, lock, NULL);
 }
 
@@ -2700,7 +2704,7 @@ void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page
 static
 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         struct request_sense sense;
         struct atapi_capabilities_page cap;
         int stat;
@@ -2723,7 +2727,7 @@ int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
 static
 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         struct media_event_desc med;
         struct request_sense sense;
         int stat;
@@ -2769,7 +2773,7 @@ int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
                                 struct cdrom_multisession *ms_info)
 {
         struct atapi_toc *toc;
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         struct cdrom_info *info = drive->driver_data;
         struct request_sense sense;
         int ret;
@@ -2791,7 +2795,7 @@ int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
 {
         int stat;
         char mcnbuf[24];
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
 
 /* get MCN */
         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
@@ -2815,7 +2819,7 @@ static
 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
                                        int slot_nr)
 {
-        ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+        ide_drive_t *drive = cdi->handle;
         int retval;
         
         if (slot_nr == CDSL_CURRENT) {
@@ -2886,7 +2890,7 @@ static int ide_cdrom_register (ide_drive_t *drive, int nslots)
         devinfo->mask = 0;
         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
         devinfo->capacity = nslots;
-        devinfo->handle = (void *) drive;
+        devinfo->handle = drive;
         strcpy(devinfo->name, drive->name);
         
         /* set capability mask to match the probe. */
@@ -2942,7 +2946,7 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
          * registered with the Uniform layer yet, it can't do this.
          * Same goes for cdi->ops.
          */
-        cdi->handle = (ide_drive_t *) drive;
+        cdi->handle = drive;
         cdi->ops = &ide_cdrom_dops;
 
         if (ide_cdrom_get_capabilities(drive, &cap))
@@ -3254,6 +3258,7 @@ int ide_cdrom_setup (ide_drive_t *drive)
         return 0;
 }
 
+#ifdef CONFIG_PROC_FS
 static
 sector_t ide_cdrom_capacity (ide_drive_t *drive)
 {
@@ -3264,6 +3269,7 @@ sector_t ide_cdrom_capacity (ide_drive_t *drive)
 
         return capacity * sectors_per_frame;
 }
+#endif
 
 static int ide_cd_remove(struct device *dev)
 {
@@ -3309,7 +3315,7 @@ static int ide_cd_probe(struct device *);
 static int proc_idecd_read_capacity
         (char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        ide_drive_t*drive = (ide_drive_t *)data;
+        ide_drive_t *drive = data;
         int len;
 
         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
@@ -3449,7 +3455,7 @@ static int ide_cd_probe(struct device *dev)
                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
                 goto failed;
         }
-        info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
+        info = kmalloc(sizeof(struct cdrom_info), GFP_KERNEL);
         if (info == NULL) {
                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
                 goto failed;
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index 4063d2c34e3d..84665e2ba3c8 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -64,6 +64,7 @@ static int proc_ide_read_imodel
                 case ide_cy82c693:      name = "cy82c693";      break;
                 case ide_4drives:       name = "4drives";       break;
                 case ide_pmac:          name = "mac-io";        break;
+                case ide_au1xxx:        name = "au1xxx";        break;
                 default:                name = "(unknown)";     break;
         }
         len = sprintf(page, "%s\n", name);
diff --git a/drivers/ide/mips/au1xxx-ide.c b/drivers/ide/mips/au1xxx-ide.c
new file mode 100644
index 000000000000..2b6327c576b9
--- /dev/null
+++ b/drivers/ide/mips/au1xxx-ide.c
@@ -0,0 +1,1250 @@
+/*
+ * linux/drivers/ide/mips/au1xxx-ide.c  version 01.30.00        Aug. 02 2005
+ *
+ * BRIEF MODULE DESCRIPTION
+ * AMD Alchemy Au1xxx IDE interface routines over the Static Bus
+ *
+ * Copyright (c) 2003-2005 AMD, Personal Connectivity Solutions
+ *
+ * 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 SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Note: for more information, please refer "AMD Alchemy Au1200/Au1550 IDE
+ *       Interface and Linux Device Driver" Application Note.
+ */
+#undef REALLY_SLOW_IO           /* most systems can safely undef this */
+
+#include <linux/config.h>       /* for CONFIG_BLK_DEV_IDEPCI */
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/timer.h>
+#include <linux/mm.h>
+#include <linux/ioport.h>
+#include <linux/hdreg.h>
+#include <linux/init.h>
+#include <linux/ide.h>
+#include <linux/sysdev.h>
+
+#include <linux/dma-mapping.h>
+
+#include <asm/io.h>
+#include <asm/mach-au1x00/au1xxx.h>
+#include <asm/mach-au1x00/au1xxx_dbdma.h>
+
+#if CONFIG_PM
+#include <asm/mach-au1x00/au1xxx_pm.h>
+#endif
+
+#include <asm/mach-au1x00/au1xxx_ide.h>
+
+#define DRV_NAME        "au1200-ide"
+#define DRV_VERSION     "1.0"
+#define DRV_AUTHOR      "AMD PCS / Pete Popov <ppopov@embeddedalley.com>"
+#define DRV_DESC        "Au1200 IDE"
+
+static _auide_hwif auide_hwif;
+static spinlock_t ide_tune_drive_spin_lock = SPIN_LOCK_UNLOCKED;
+static spinlock_t ide_tune_chipset_spin_lock = SPIN_LOCK_UNLOCKED;
+static int dbdma_init_done = 0;
+
+/*
+ * local I/O functions
+ */
+u8 auide_inb(unsigned long port)
+{
+        return (au_readb(port));
+}
+
+u16 auide_inw(unsigned long port)
+{
+        return (au_readw(port));
+}
+
+u32 auide_inl(unsigned long port)
+{
+        return (au_readl(port));
+}
+
+void auide_insw(unsigned long port, void *addr, u32 count)
+{
+#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA)
+
+        _auide_hwif *ahwif = &auide_hwif;
+        chan_tab_t *ctp;
+        au1x_ddma_desc_t *dp;
+
+        if(!put_dest_flags(ahwif->rx_chan, (void*)addr, count << 1,
+                                DDMA_FLAGS_NOIE)) {
+                printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__);
+                return;
+        }
+        ctp = *((chan_tab_t **)ahwif->rx_chan);
+        dp = ctp->cur_ptr;
+        while (dp->dscr_cmd0 & DSCR_CMD0_V)
+                ;
+        ctp->cur_ptr = au1xxx_ddma_get_nextptr_virt(dp);
+#else
+        while (count--)
+        {
+                *(u16 *)addr = au_readw(port);
+                addr +=2 ;
+        }
+#endif
+}
+
+void auide_insl(unsigned long port, void *addr, u32 count)
+{
+        while (count--)
+        {
+                *(u32 *)addr = au_readl(port);
+                /* NOTE: For IDE interfaces over PCMCIA,
+                 * 32-bit access does not work
+                 */
+                addr += 4;
+        }
+}
+
+void auide_outb(u8 addr, unsigned long port)
+{
+        return (au_writeb(addr, port));
+}
+
+void auide_outbsync(ide_drive_t *drive, u8 addr, unsigned long port)
+{
+        return (au_writeb(addr, port));
+}
+
+void auide_outw(u16 addr, unsigned long port)
+{
+        return (au_writew(addr, port));
+}
+
+void auide_outl(u32 addr, unsigned long port)
+{
+        return (au_writel(addr, port));
+}
+
+void auide_outsw(unsigned long port, void *addr, u32 count)
+{
+#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA)
+        _auide_hwif *ahwif = &auide_hwif;
+        chan_tab_t *ctp;
+        au1x_ddma_desc_t *dp;
+
+        if(!put_source_flags(ahwif->tx_chan, (void*)addr,
+                                          count << 1, DDMA_FLAGS_NOIE)) {
+                printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__);
+                return;
+        }
+        ctp = *((chan_tab_t **)ahwif->tx_chan);
+        dp = ctp->cur_ptr;
+        while (dp->dscr_cmd0 & DSCR_CMD0_V)
+                ;
+        ctp->cur_ptr = au1xxx_ddma_get_nextptr_virt(dp);
+#else
+        while (count--)
+        {
+                au_writew(*(u16 *)addr, port);
+                addr += 2;
+        }
+#endif
+}
+
+void auide_outsl(unsigned long port, void *addr, u32 count)
+{
+        while (count--)
+        {
+                au_writel(*(u32 *)addr, port);
+                /* NOTE: For IDE interfaces over PCMCIA,
+                 * 32-bit access does not work
+                 */
+                addr += 4;
+        }
+}
+
+static void auide_tune_drive(ide_drive_t *drive, byte pio)
+{
+        int mem_sttime;
+        int mem_stcfg;
+        unsigned long flags;
+        u8 speed;
+
+        /* get the best pio mode for the drive */
+        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+
+        printk("%s: setting Au1XXX IDE to PIO mode%d\n",
+                drive->name, pio);
+
+        spin_lock_irqsave(&ide_tune_drive_spin_lock, flags);
+
+        mem_sttime = 0;
+        mem_stcfg  = au_readl(MEM_STCFG2);
+
+        /* set pio mode! */
+        switch(pio) {
+                case 0:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_PIO0_TWCS
+                                     | SBC_IDE_PIO0_TCSH
+                                     | SBC_IDE_PIO0_TCSOFF
+                                     | SBC_IDE_PIO0_TWP
+                                     | SBC_IDE_PIO0_TCSW
+                                     | SBC_IDE_PIO0_TPM
+                                     | SBC_IDE_PIO0_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg |= TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_PIO0_TCSOE | SBC_IDE_PIO0_TOECS;
+
+                        au_writel(mem_sttime,MEM_STTIME2);
+                        au_writel(mem_stcfg,MEM_STCFG2);
+                        break;
+
+                case 1:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_PIO1_TWCS
+                                     | SBC_IDE_PIO1_TCSH
+                                     | SBC_IDE_PIO1_TCSOFF
+                                     | SBC_IDE_PIO1_TWP
+                                     | SBC_IDE_PIO1_TCSW
+                                     | SBC_IDE_PIO1_TPM
+                                     | SBC_IDE_PIO1_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg |= TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_PIO1_TCSOE | SBC_IDE_PIO1_TOECS;
+                        break;
+
+                case 2:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_PIO2_TWCS
+                                     | SBC_IDE_PIO2_TCSH
+                                     | SBC_IDE_PIO2_TCSOFF
+                                     | SBC_IDE_PIO2_TWP
+                                     | SBC_IDE_PIO2_TCSW
+                                     | SBC_IDE_PIO2_TPM
+                                     | SBC_IDE_PIO2_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg &= ~TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_PIO2_TCSOE | SBC_IDE_PIO2_TOECS;
+                        break;
+
+                case 3:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_PIO3_TWCS
+                                     | SBC_IDE_PIO3_TCSH
+                                     | SBC_IDE_PIO3_TCSOFF
+                                     | SBC_IDE_PIO3_TWP
+                                     | SBC_IDE_PIO3_TCSW
+                                     | SBC_IDE_PIO3_TPM
+                                     | SBC_IDE_PIO3_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg |= TS_MASK;
+                        mem_stcfg &= ~TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_PIO3_TCSOE | SBC_IDE_PIO3_TOECS;
+
+                        break;
+
+                case 4:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_PIO4_TWCS
+                                     | SBC_IDE_PIO4_TCSH
+                                     | SBC_IDE_PIO4_TCSOFF
+                                     | SBC_IDE_PIO4_TWP
+                                     | SBC_IDE_PIO4_TCSW
+                                     | SBC_IDE_PIO4_TPM
+                                     | SBC_IDE_PIO4_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg &= ~TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_PIO4_TCSOE | SBC_IDE_PIO4_TOECS;
+                        break;
+        }
+
+        au_writel(mem_sttime,MEM_STTIME2);
+        au_writel(mem_stcfg,MEM_STCFG2);
+
+        spin_unlock_irqrestore(&ide_tune_drive_spin_lock, flags);
+
+        speed = pio + XFER_PIO_0;
+        ide_config_drive_speed(drive, speed);
+}
+
+static int auide_tune_chipset (ide_drive_t *drive, u8 speed)
+{
+        u8 mode = 0;
+        int mem_sttime;
+        int mem_stcfg;
+        unsigned long flags;
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+        struct hd_driveid *id = drive->id;
+
+        /*
+         * Now see what the current drive is capable of,
+         * selecting UDMA only if the mate said it was ok.
+         */
+        if (id && (id->capability & 1) && drive->autodma &&
+            !__ide_dma_bad_drive(drive)) {
+                if (!mode && (id->field_valid & 2) && (id->dma_mword & 7)) {
+                        if      (id->dma_mword & 4)
+                                mode = XFER_MW_DMA_2;
+                        else if (id->dma_mword & 2)
+                                mode = XFER_MW_DMA_1;
+                        else if (id->dma_mword & 1)
+                                mode = XFER_MW_DMA_0;
+                }
+        }
+#endif
+
+        spin_lock_irqsave(&ide_tune_chipset_spin_lock, flags);
+
+        mem_sttime = 0;
+        mem_stcfg  = au_readl(MEM_STCFG2);
+
+        switch(speed) {
+                case XFER_PIO_4:
+                case XFER_PIO_3:
+                case XFER_PIO_2:
+                case XFER_PIO_1:
+                case XFER_PIO_0:
+                        auide_tune_drive(drive, (speed - XFER_PIO_0));
+                        break;
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+                case XFER_MW_DMA_2:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_MDMA2_TWCS
+                                     | SBC_IDE_MDMA2_TCSH
+                                     | SBC_IDE_MDMA2_TCSOFF
+                                     | SBC_IDE_MDMA2_TWP
+                                     | SBC_IDE_MDMA2_TCSW
+                                     | SBC_IDE_MDMA2_TPM
+                                     | SBC_IDE_MDMA2_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg &= ~TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_MDMA2_TCSOE | SBC_IDE_MDMA2_TOECS;
+
+                        mode = XFER_MW_DMA_2;
+                        break;
+                case XFER_MW_DMA_1:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_MDMA1_TWCS
+                                     | SBC_IDE_MDMA1_TCSH
+                                     | SBC_IDE_MDMA1_TCSOFF
+                                     | SBC_IDE_MDMA1_TWP
+                                     | SBC_IDE_MDMA1_TCSW
+                                     | SBC_IDE_MDMA1_TPM
+                                     | SBC_IDE_MDMA1_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg &= ~TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_MDMA1_TCSOE | SBC_IDE_MDMA1_TOECS;
+
+                        mode = XFER_MW_DMA_1;
+                        break;
+                case XFER_MW_DMA_0:
+                        /* set timing parameters for RCS2# */
+                        mem_sttime =   SBC_IDE_MDMA0_TWCS
+                                     | SBC_IDE_MDMA0_TCSH
+                                     | SBC_IDE_MDMA0_TCSOFF
+                                     | SBC_IDE_MDMA0_TWP
+                                     | SBC_IDE_MDMA0_TCSW
+                                     | SBC_IDE_MDMA0_TPM
+                                     | SBC_IDE_MDMA0_TA;
+                        /* set configuration for RCS2# */
+                        mem_stcfg |= TS_MASK;
+                        mem_stcfg &= ~TCSOE_MASK;
+                        mem_stcfg &= ~TOECS_MASK;
+                        mem_stcfg |= SBC_IDE_MDMA0_TCSOE | SBC_IDE_MDMA0_TOECS;
+
+                        mode = XFER_MW_DMA_0;
+                        break;
+#endif
+                default:
+                        return 1;
+        }
+
+        /*
+         * Tell the drive to switch to the new mode; abort on failure.
+         */
+        if (!mode || ide_config_drive_speed(drive, mode))
+        {
+                return 1;       /* failure */
+        }
+
+
+        au_writel(mem_sttime,MEM_STTIME2);
+        au_writel(mem_stcfg,MEM_STCFG2);
+
+        spin_unlock_irqrestore(&ide_tune_chipset_spin_lock, flags);
+
+        return 0;
+}
+
+/*
+ * Multi-Word DMA + DbDMA functions
+ */
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+
+static int in_drive_list(struct hd_driveid *id,
+                         const struct drive_list_entry *drive_table)
+{
+        for ( ; drive_table->id_model ; drive_table++){
+                if ((!strcmp(drive_table->id_model, id->model)) &&
+                        ((strstr(drive_table->id_firmware, id->fw_rev)) ||
+                        (!strcmp(drive_table->id_firmware, "ALL")))
+                )
+                        return 1;
+        }
+        return 0;
+}
+
+static int auide_build_sglist(ide_drive_t *drive,  struct request *rq)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        _auide_hwif *ahwif = (_auide_hwif*)hwif->hwif_data;
+        struct scatterlist *sg = hwif->sg_table;
+
+        ide_map_sg(drive, rq);
+
+        if (rq_data_dir(rq) == READ)
+                hwif->sg_dma_direction = DMA_FROM_DEVICE;
+        else
+                hwif->sg_dma_direction = DMA_TO_DEVICE;
+
+        return dma_map_sg(ahwif->dev, sg, hwif->sg_nents,
+                          hwif->sg_dma_direction);
+}
+
+static int auide_build_dmatable(ide_drive_t *drive)
+{
+        int i, iswrite, count = 0;
+        ide_hwif_t *hwif = HWIF(drive);
+
+        struct request *rq = HWGROUP(drive)->rq;
+
+        _auide_hwif *ahwif = (_auide_hwif*)hwif->hwif_data;
+        struct scatterlist *sg;
+
+        iswrite = (rq_data_dir(rq) == WRITE);
+        /* Save for interrupt context */
+        ahwif->drive = drive;
+
+        /* Build sglist */
+        hwif->sg_nents = i = auide_build_sglist(drive, rq);
+
+        if (!i)
+                return 0;
+
+        /* fill the descriptors */
+        sg = hwif->sg_table;
+        while (i && sg_dma_len(sg)) {
+                u32 cur_addr;
+                u32 cur_len;
+
+                cur_addr = sg_dma_address(sg);
+                cur_len = sg_dma_len(sg);
+
+                while (cur_len) {
+                        u32 flags = DDMA_FLAGS_NOIE;
+                        unsigned int tc = (cur_len < 0xfe00)? cur_len: 0xfe00;
+
+                        if (++count >= PRD_ENTRIES) {
+                                printk(KERN_WARNING "%s: DMA table too small\n",
+                                drive->name);
+                                goto use_pio_instead;
+                        }
+
+                        /* Lets enable intr for the last descriptor only */
+                        if (1==i)
+                                flags = DDMA_FLAGS_IE;
+                        else
+                                flags = DDMA_FLAGS_NOIE;
+
+                        if (iswrite) {
+                                if(!put_source_flags(ahwif->tx_chan,
+                                                (void*)(page_address(sg->page)
+                                                        + sg->offset),
+                                                tc, flags)) {
+                                        printk(KERN_ERR "%s failed %d\n",
+                                                        __FUNCTION__, __LINE__);
+                                }
+                        } else
+                        {
+                                if(!put_dest_flags(ahwif->rx_chan,
+                                                (void*)(page_address(sg->page)
+                                                        + sg->offset),
+                                                tc, flags)) {
+                                        printk(KERN_ERR "%s failed %d\n",
+                                                        __FUNCTION__, __LINE__);
+                                }
+                        }
+
+                        cur_addr += tc;
+                        cur_len -= tc;
+                }
+                sg++;
+                i--;
+        }
+
+        if (count)
+                return 1;
+
+use_pio_instead:
+        dma_unmap_sg(ahwif->dev,
+                     hwif->sg_table,
+                     hwif->sg_nents,
+                     hwif->sg_dma_direction);
+
+        return 0; /* revert to PIO for this request */
+}
+
+static int auide_dma_end(ide_drive_t *drive)
+{
+        ide_hwif_t *hwif = HWIF(drive);
+        _auide_hwif *ahwif = (_auide_hwif*)hwif->hwif_data;
+
+        if (hwif->sg_nents) {
+                dma_unmap_sg(ahwif->dev, hwif->sg_table, hwif->sg_nents,
+                             hwif->sg_dma_direction);
+                hwif->sg_nents = 0;
+        }
+
+        return 0;
+}
+
+static void auide_dma_start(ide_drive_t *drive )
+{
+//      printk("%s\n", __FUNCTION__);
+}
+
+ide_startstop_t auide_dma_intr(ide_drive_t *drive)
+{
+        //printk("%s\n", __FUNCTION__);
+
+        u8 stat = 0, dma_stat = 0;
+
+        dma_stat = HWIF(drive)->ide_dma_end(drive);
+        stat = HWIF(drive)->INB(IDE_STATUS_REG);        /* get drive status */
+        if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
+                if (!dma_stat) {
+                        struct request *rq = HWGROUP(drive)->rq;
+
+                        ide_end_request(drive, 1, rq->nr_sectors);
+                        return ide_stopped;
+                }
+                printk(KERN_ERR "%s: dma_intr: bad DMA status (dma_stat=%x)\n",
+                                 drive->name, dma_stat);
+        }
+        return ide_error(drive, "dma_intr", stat);
+}
+
+static void auide_dma_exec_cmd(ide_drive_t *drive, u8 command)
+{
+        //printk("%s\n", __FUNCTION__);
+
+        /* issue cmd to drive */
+        ide_execute_command(drive, command, &auide_dma_intr,
+                            (2*WAIT_CMD), NULL);
+}
+
+static int auide_dma_setup(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+
+        if (drive->media != ide_disk)
+                return 1;
+
+        if (!auide_build_dmatable(drive))
+                        /* try PIO instead of DMA */
+                        return 1;
+
+        drive->waiting_for_dma = 1;
+
+        return 0;
+}
+
+static int auide_dma_check(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+        if( !dbdma_init_done ){
+                auide_hwif.white_list = in_drive_list(drive->id,
+                                                      dma_white_list);
+                auide_hwif.black_list = in_drive_list(drive->id,
+                                                      dma_black_list);
+                auide_hwif.drive = drive;
+                auide_ddma_init(&auide_hwif);
+                dbdma_init_done = 1;
+        }
+#endif
+
+        /* Is the drive in our DMA black list? */
+        if ( auide_hwif.black_list ) {
+                drive->using_dma = 0;
+                printk("%s found in dma_blacklist[]! Disabling DMA.\n",
+                drive->id->model);
+        }
+        else
+                drive->using_dma = 1;
+
+        return HWIF(drive)->ide_dma_host_on(drive);
+}
+
+static int auide_dma_test_irq(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+
+        if (!drive->waiting_for_dma)
+                printk(KERN_WARNING "%s: ide_dma_test_irq \
+                                     called while not waiting\n", drive->name);
+
+        /* If dbdma didn't execute the STOP command yet, the
+         * active bit is still set
+         */
+        drive->waiting_for_dma++;
+        if (drive->waiting_for_dma >= DMA_WAIT_TIMEOUT) {
+                printk(KERN_WARNING "%s: timeout waiting for ddma to \
+                                     complete\n", drive->name);
+                return 1;
+        }
+        udelay(10);
+        return 0;
+}
+
+static int auide_dma_host_on(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+        return 0;
+}
+
+static int auide_dma_on(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+        drive->using_dma = 1;
+        return auide_dma_host_on(drive);
+}
+
+
+static int auide_dma_host_off(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+        return 0;
+}
+
+static int auide_dma_off_quietly(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+        drive->using_dma = 0;
+        return auide_dma_host_off(drive);
+}
+
+static int auide_dma_lostirq(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+
+        printk(KERN_ERR "%s: IRQ lost\n", drive->name);
+        return 0;
+}
+
+static void auide_ddma_tx_callback(int irq, void *param, struct pt_regs *regs)
+{
+//      printk("%s\n", __FUNCTION__);
+
+        _auide_hwif *ahwif = (_auide_hwif*)param;
+        ahwif->drive->waiting_for_dma = 0;
+        return;
+}
+
+static void auide_ddma_rx_callback(int irq, void *param, struct pt_regs *regs)
+{
+//      printk("%s\n", __FUNCTION__);
+
+        _auide_hwif *ahwif = (_auide_hwif*)param;
+        ahwif->drive->waiting_for_dma = 0;
+        return;
+}
+
+static int auide_dma_timeout(ide_drive_t *drive)
+{
+//      printk("%s\n", __FUNCTION__);
+
+        printk(KERN_ERR "%s: DMA timeout occurred: ", drive->name);
+
+        if (HWIF(drive)->ide_dma_test_irq(drive))
+                return 0;
+
+        return HWIF(drive)->ide_dma_end(drive);
+}
+#endif /* end CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA */
+
+
+static int auide_ddma_init( _auide_hwif *auide )
+{
+//      printk("%s\n", __FUNCTION__);
+
+        dbdev_tab_t source_dev_tab;
+#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
+        dbdev_tab_t target_dev_tab;
+        ide_hwif_t *hwif = auide->hwif;
+        char warning_output [2][80];
+        int i;
+#endif
+
+        /* Add our custom device to DDMA device table */
+        /* Create our new device entries in the table */
+#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
+        source_dev_tab.dev_id = AU1XXX_ATA_DDMA_REQ;
+
+        if( auide->white_list || auide->black_list ){
+                source_dev_tab.dev_tsize       = 8;
+                source_dev_tab.dev_devwidth    = 32;
+                source_dev_tab.dev_physaddr    = (u32)AU1XXX_ATA_PHYS_ADDR;
+                source_dev_tab.dev_intlevel    = 0;
+                source_dev_tab.dev_intpolarity = 0;
+
+                /* init device table for target - static bus controller - */
+                target_dev_tab.dev_id          = DSCR_CMD0_ALWAYS;
+                target_dev_tab.dev_tsize       = 8;
+                target_dev_tab.dev_devwidth    = 32;
+                target_dev_tab.dev_physaddr    = (u32)AU1XXX_ATA_PHYS_ADDR;
+                target_dev_tab.dev_intlevel    = 0;
+                target_dev_tab.dev_intpolarity = 0;
+                target_dev_tab.dev_flags       = DEV_FLAGS_ANYUSE;
+        }
+        else{
+                source_dev_tab.dev_tsize       = 1;
+                source_dev_tab.dev_devwidth    = 16;
+                source_dev_tab.dev_physaddr    = (u32)AU1XXX_ATA_PHYS_ADDR;
+                source_dev_tab.dev_intlevel    = 0;
+                source_dev_tab.dev_intpolarity = 0;
+
+                /* init device table for target - static bus controller - */
+                target_dev_tab.dev_id          = DSCR_CMD0_ALWAYS;
+                target_dev_tab.dev_tsize       = 1;
+                target_dev_tab.dev_devwidth    = 16;
+                target_dev_tab.dev_physaddr    = (u32)AU1XXX_ATA_PHYS_ADDR;
+                target_dev_tab.dev_intlevel    = 0;
+                target_dev_tab.dev_intpolarity = 0;
+                target_dev_tab.dev_flags       = DEV_FLAGS_ANYUSE;
+
+                sprintf(&warning_output[0][0],
+                        "%s is not on ide driver white list.",
+                        auide_hwif.drive->id->model);
+                for ( i=strlen(&warning_output[0][0]) ; i<76; i++ ){
+                        sprintf(&warning_output[0][i]," ");
+                }
+
+                sprintf(&warning_output[1][0],
+                "To add %s please read 'Documentation/mips/AU1xxx_IDE.README'.",
+                        auide_hwif.drive->id->model);
+                for ( i=strlen(&warning_output[1][0]) ; i<76; i++ ){
+                        sprintf(&warning_output[1][i]," ");
+                }
+
+                printk("\n****************************************");
+                printk("****************************************\n");
+                printk("* %s *\n",&warning_output[0][0]);
+                printk("* Switch to safe MWDMA Mode!            ");
+                printk("                                       *\n");
+                printk("* %s *\n",&warning_output[1][0]);
+                printk("****************************************");
+                printk("****************************************\n\n");
+        }
+#else
+        source_dev_tab.dev_id = DSCR_CMD0_ALWAYS;
+        source_dev_tab.dev_tsize       = 8;
+        source_dev_tab.dev_devwidth    = 32;
+        source_dev_tab.dev_physaddr    = (u32)AU1XXX_ATA_PHYS_ADDR;
+        source_dev_tab.dev_intlevel    = 0;
+        source_dev_tab.dev_intpolarity = 0;
+#endif
+
+#if CONFIG_BLK_DEV_IDE_AU1XXX_BURSTABLE_ON
+        /* set flags for tx channel */
+        source_dev_tab.dev_flags =  DEV_FLAGS_OUT
+                                  | DEV_FLAGS_SYNC
+                                  | DEV_FLAGS_BURSTABLE;
+        auide->tx_dev_id = au1xxx_ddma_add_device( &source_dev_tab );
+        /* set flags for rx channel */
+        source_dev_tab.dev_flags =  DEV_FLAGS_IN
+                                  | DEV_FLAGS_SYNC
+                                  | DEV_FLAGS_BURSTABLE;
+        auide->rx_dev_id = au1xxx_ddma_add_device( &source_dev_tab );
+#else
+        /* set flags for tx channel */
+        source_dev_tab.dev_flags = DEV_FLAGS_OUT | DEV_FLAGS_SYNC;
+        auide->tx_dev_id         = au1xxx_ddma_add_device( &source_dev_tab );
+        /* set flags for rx channel */
+        source_dev_tab.dev_flags = DEV_FLAGS_IN | DEV_FLAGS_SYNC;
+        auide->rx_dev_id         = au1xxx_ddma_add_device( &source_dev_tab );
+#endif
+
+#if  defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
+
+        auide->target_dev_id           = au1xxx_ddma_add_device(&target_dev_tab);
+
+        /* Get a channel for TX */
+        auide->tx_chan = au1xxx_dbdma_chan_alloc(auide->target_dev_id,
+                                                 auide->tx_dev_id,
+                                                 auide_ddma_tx_callback,
+                                                 (void*)auide);
+        /* Get a channel for RX */
+        auide->rx_chan = au1xxx_dbdma_chan_alloc(auide->rx_dev_id,
+                                                 auide->target_dev_id,
+                                                 auide_ddma_rx_callback,
+                                                 (void*)auide);
+#else   /* CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA */
+        /*
+         * Note: if call back is not enabled, update ctp->cur_ptr manually
+         */
+        auide->tx_chan = au1xxx_dbdma_chan_alloc(DSCR_CMD0_ALWAYS,
+                                                 auide->tx_dev_id,
+                                                 NULL,
+                                                 (void*)auide);
+        auide->rx_chan = au1xxx_dbdma_chan_alloc(auide->rx_dev_id,
+                                                 DSCR_CMD0_ALWAYS,
+                                                 NULL,
+                                                 (void*)auide);
+#endif
+        auide->tx_desc_head = (void*)au1xxx_dbdma_ring_alloc(auide->tx_chan,
+                                                             NUM_DESCRIPTORS);
+        auide->rx_desc_head = (void*)au1xxx_dbdma_ring_alloc(auide->rx_chan,
+                                                             NUM_DESCRIPTORS);
+
+#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
+        hwif->dmatable_cpu = dma_alloc_coherent(auide->dev,
+                                                PRD_ENTRIES * PRD_BYTES,        /* 1 Page */
+                                                &hwif->dmatable_dma, GFP_KERNEL);
+
+        auide->sg_table = kmalloc(sizeof(struct scatterlist) * PRD_ENTRIES,
+                                GFP_KERNEL|GFP_DMA);
+        if (auide->sg_table == NULL) {
+                return -ENOMEM;
+        }
+#endif
+        au1xxx_dbdma_start( auide->tx_chan );
+        au1xxx_dbdma_start( auide->rx_chan );
+        return 0;
+}
+
+static void auide_setup_ports(hw_regs_t *hw, _auide_hwif *ahwif)
+{
+        int i;
+#define ide_ioreg_t unsigned long
+        ide_ioreg_t *ata_regs = hw->io_ports;
+
+        /* fixme */
+        for (i = 0; i < IDE_CONTROL_OFFSET; i++) {
+                *ata_regs++ = (ide_ioreg_t) ahwif->regbase
+                            + (ide_ioreg_t)(i << AU1XXX_ATA_REG_OFFSET);
+        }
+
+        /* set the Alternative Status register */
+        *ata_regs = (ide_ioreg_t) ahwif->regbase
+                  + (ide_ioreg_t)(14 << AU1XXX_ATA_REG_OFFSET);
+}
+
+static int au_ide_probe(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        _auide_hwif *ahwif = &auide_hwif;
+        ide_hwif_t *hwif;
+        struct resource *res;
+        int ret = 0;
+
+#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
+        char *mode = "MWDMA2";
+#elif defined(CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA)
+        char *mode = "PIO+DDMA(offload)";
+#endif
+
+        memset(&auide_hwif, 0, sizeof(_auide_hwif));
+        auide_hwif.dev                  = 0;
+
+        ahwif->dev = dev;
+        ahwif->irq = platform_get_irq(pdev, 0);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        if (res == NULL) {
+                pr_debug("%s %d: no base address\n", DRV_NAME, pdev->id);
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (!request_mem_region (res->start, res->end-res->start, pdev->name)) {
+                pr_debug("%s: request_mem_region failed\n", DRV_NAME);
+                ret =  -EBUSY;
+                goto out;
+        }
+
+        ahwif->regbase = (u32)ioremap(res->start, res->end-res->start);
+        if (ahwif->regbase == 0) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        hwif                            = &ide_hwifs[pdev->id];
+        hw_regs_t *hw                   = &hwif->hw;
+        hwif->irq = hw->irq             = ahwif->irq;
+        hwif->chipset                   = ide_au1xxx;
+
+        auide_setup_ports(hw, ahwif);
+        memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports));
+
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ
+        hwif->rqsize = CONFIG_BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ;
+        hwif->rqsize                    = ((hwif->rqsize > AU1XXX_ATA_RQSIZE)
+                                        || (hwif->rqsize < 32)) ? AU1XXX_ATA_RQSIZE : hwif->rqsize;
+#else /* if kernel config is not set */
+        hwif->rqsize                    = AU1XXX_ATA_RQSIZE;
+#endif
+
+        hwif->ultra_mask                = 0x0;  /* Disable Ultra DMA */
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+        hwif->mwdma_mask                = 0x07; /* Multimode-2 DMA  */
+        hwif->swdma_mask                = 0x07;
+#else
+        hwif->mwdma_mask                = 0x0;
+        hwif->swdma_mask                = 0x0;
+#endif
+        //hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET];
+        hwif->noprobe = 0;
+        hwif->drives[0].unmask          = 1;
+        hwif->drives[1].unmask          = 1;
+
+        /* hold should be on in all cases */
+        hwif->hold                      = 1;
+        hwif->mmio                      = 2;
+
+        /* set up local I/O function entry points */
+        hwif->INB                       = auide_inb;
+        hwif->INW                       = auide_inw;
+        hwif->INL                       = auide_inl;
+        hwif->INSW                      = auide_insw;
+        hwif->INSL                      = auide_insl;
+        hwif->OUTB                      = auide_outb;
+        hwif->OUTBSYNC                  = auide_outbsync;
+        hwif->OUTW                      = auide_outw;
+        hwif->OUTL                      = auide_outl;
+        hwif->OUTSW                     = auide_outsw;
+        hwif->OUTSL                     = auide_outsl;
+
+        hwif->tuneproc                  = &auide_tune_drive;
+        hwif->speedproc                 = &auide_tune_chipset;
+
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
+        hwif->ide_dma_off_quietly       = &auide_dma_off_quietly;
+        hwif->ide_dma_timeout           = &auide_dma_timeout;
+
+        hwif->ide_dma_check             = &auide_dma_check;
+        hwif->dma_exec_cmd              = &auide_dma_exec_cmd;
+        hwif->dma_start                 = &auide_dma_start;
+        hwif->ide_dma_end               = &auide_dma_end;
+        hwif->dma_setup                 = &auide_dma_setup;
+        hwif->ide_dma_test_irq          = &auide_dma_test_irq;
+        hwif->ide_dma_host_off          = &auide_dma_host_off;
+        hwif->ide_dma_host_on           = &auide_dma_host_on;
+        hwif->ide_dma_lostirq           = &auide_dma_lostirq;
+        hwif->ide_dma_on                = &auide_dma_on;
+
+        hwif->autodma                   = 1;
+        hwif->drives[0].autodma         = hwif->autodma;
+        hwif->drives[1].autodma         = hwif->autodma;
+        hwif->atapi_dma                 = 1;
+        hwif->drives[0].using_dma       = 1;
+        hwif->drives[1].using_dma       = 1;
+#else /* !CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA */
+        hwif->autodma                   = 0;
+        hwif->channel                   = 0;
+        hwif->hold                      = 1;
+        hwif->select_data               = 0;    /* no chipset-specific code */
+        hwif->config_data               = 0;    /* no chipset-specific code */
+
+        hwif->drives[0].autodma         = 0;
+        hwif->drives[0].drive_data      = 0;    /* no drive data */
+        hwif->drives[0].using_dma       = 0;
+        hwif->drives[0].waiting_for_dma = 0;
+        hwif->drives[0].autotune        = 1;    /* 1=autotune, 2=noautotune, 0=default */
+        /* secondary hdd not supported */
+        hwif->drives[1].autodma         = 0;
+
+        hwif->drives[1].drive_data      = 0;
+        hwif->drives[1].using_dma       = 0;
+        hwif->drives[1].waiting_for_dma = 0;
+        hwif->drives[1].autotune        = 2;   /* 1=autotune, 2=noautotune, 0=default */
+#endif
+        hwif->drives[0].io_32bit        = 0;   /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
+        hwif->drives[1].io_32bit        = 0;   /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
+
+        /*Register Driver with PM Framework*/
+#ifdef CONFIG_PM
+        auide_hwif.pm.lock    = SPIN_LOCK_UNLOCKED;
+        auide_hwif.pm.stopped = 0;
+
+        auide_hwif.pm.dev = new_au1xxx_power_device( "ide",
+                                                &au1200ide_pm_callback,
+                                                NULL);
+        if ( auide_hwif.pm.dev == NULL )
+                printk(KERN_INFO "Unable to create a power management \
+                                device entry for the au1200-IDE.\n");
+        else
+                printk(KERN_INFO "Power management device entry for the \
+                                au1200-IDE loaded.\n");
+#endif
+
+        auide_hwif.hwif                 = hwif;
+        hwif->hwif_data                 = &auide_hwif;
+
+#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA
+        auide_ddma_init(&auide_hwif);
+        dbdma_init_done = 1;
+#endif
+
+        probe_hwif_init(hwif);
+        dev_set_drvdata(dev, hwif);
+
+        printk(KERN_INFO "Au1xxx IDE(builtin) configured for %s\n", mode );
+
+out:
+        return ret;
+}
+
+static int au_ide_remove(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct resource *res;
+        ide_hwif_t *hwif = dev_get_drvdata(dev);
+        _auide_hwif *ahwif = &auide_hwif;
+
+        ide_unregister(hwif - ide_hwifs);
+
+        iounmap((void *)ahwif->regbase);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, res->end - res->start);
+
+        return 0;
+}
+
+static struct device_driver au1200_ide_driver = {
+        .name           = "au1200-ide",
+        .bus            = &platform_bus_type,
+        .probe          = au_ide_probe,
+        .remove         = au_ide_remove,
+};
+
+static int __init au_ide_init(void)
+{
+        return driver_register(&au1200_ide_driver);
+}
+
+static void __init au_ide_exit(void)
+{
+        driver_unregister(&au1200_ide_driver);
+}
+
+#ifdef CONFIG_PM
+int au1200ide_pm_callback( au1xxx_power_dev_t *dev,\
+                        au1xxx_request_t request, void *data) {
+
+        unsigned int d, err = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(auide_hwif.pm.lock, flags);
+
+        switch (request){
+                case AU1XXX_PM_SLEEP:
+                        err = au1xxxide_pm_sleep(dev);
+                        break;
+                case AU1XXX_PM_WAKEUP:
+                        d = *((unsigned int*)data);
+                        if ( d > 0 && d <= 99) {
+                                err = au1xxxide_pm_standby(dev);
+                        }
+                        else {
+                                err = au1xxxide_pm_resume(dev);
+                        }
+                        break;
+                case AU1XXX_PM_GETSTATUS:
+                        err = au1xxxide_pm_getstatus(dev);
+                        break;
+                case AU1XXX_PM_ACCESS:
+                        err = au1xxxide_pm_access(dev);
+                        break;
+                case AU1XXX_PM_IDLE:
+                        err = au1xxxide_pm_idle(dev);
+                        break;
+                case AU1XXX_PM_CLEANUP:
+                        err = au1xxxide_pm_cleanup(dev);
+                        break;
+                default:
+                        err = -1;
+                        break;
+        }
+
+        spin_unlock_irqrestore(auide_hwif.pm.lock, flags);
+
+        return err;
+}
+
+static int au1xxxide_pm_standby( au1xxx_power_dev_t *dev ) {
+        return 0;
+}
+
+static int au1xxxide_pm_sleep( au1xxx_power_dev_t *dev ) {
+
+        int retval;
+        ide_hwif_t *hwif = auide_hwif.hwif;
+        struct request rq;
+        struct request_pm_state rqpm;
+        ide_task_t args;
+
+        if(auide_hwif.pm.stopped)
+                return -1;
+
+        /*
+         * wait until hard disc is ready
+         */
+        if ( wait_for_ready(&hwif->drives[0], 35000) ) {
+                printk("Wait for drive sleep timeout!\n");
+                retval = -1;
+        }
+
+        /*
+         * sequenz to tell the high level ide driver that pm is resuming
+         */
+        memset(&rq, 0, sizeof(rq));
+        memset(&rqpm, 0, sizeof(rqpm));
+        memset(&args, 0, sizeof(args));
+        rq.flags = REQ_PM_SUSPEND;
+        rq.special = &args;
+        rq.pm = &rqpm;
+        rqpm.pm_step = ide_pm_state_start_suspend;
+        rqpm.pm_state = PMSG_SUSPEND;
+
+        retval = ide_do_drive_cmd(&hwif->drives[0], &rq, ide_wait);
+
+        if (wait_for_ready (&hwif->drives[0], 35000)) {
+                printk("Wait for drive sleep timeout!\n");
+                retval = -1;
+        }
+
+        /*
+         * stop dbdma channels
+         */
+        au1xxx_dbdma_reset(auide_hwif.tx_chan);
+        au1xxx_dbdma_reset(auide_hwif.rx_chan);
+
+        auide_hwif.pm.stopped = 1;
+
+        return retval;
+}
+
+static int au1xxxide_pm_resume( au1xxx_power_dev_t *dev ) {
+
+        int retval;
+        ide_hwif_t *hwif = auide_hwif.hwif;
+        struct request rq;
+        struct request_pm_state rqpm;
+        ide_task_t args;
+
+        if(!auide_hwif.pm.stopped)
+                return -1;
+
+        /*
+         * start dbdma channels
+         */
+        au1xxx_dbdma_start(auide_hwif.tx_chan);
+        au1xxx_dbdma_start(auide_hwif.rx_chan);
+
+        /*
+         * wait until hard disc is ready
+         */
+        if (wait_for_ready ( &hwif->drives[0], 35000)) {
+                printk("Wait for drive wake up timeout!\n");
+                retval = -1;
+        }
+
+        /*
+         * sequenz to tell the high level ide driver that pm is resuming
+         */
+        memset(&rq, 0, sizeof(rq));
+        memset(&rqpm, 0, sizeof(rqpm));
+        memset(&args, 0, sizeof(args));
+        rq.flags = REQ_PM_RESUME;
+        rq.special = &args;
+        rq.pm = &rqpm;
+        rqpm.pm_step = ide_pm_state_start_resume;
+        rqpm.pm_state = PMSG_ON;
+
+        retval = ide_do_drive_cmd(&hwif->drives[0], &rq, ide_head_wait);
+
+        /*
+        * wait for hard disc
+        */
+        if ( wait_for_ready(&hwif->drives[0], 35000) ) {
+                printk("Wait for drive wake up timeout!\n");
+                retval = -1;
+        }
+
+        auide_hwif.pm.stopped = 0;
+
+        return retval;
+}
+
+static int au1xxxide_pm_getstatus( au1xxx_power_dev_t *dev ) {
+        return dev->cur_state;
+}
+
+static int au1xxxide_pm_access( au1xxx_power_dev_t *dev ) {
+        if (dev->cur_state != AWAKE_STATE)
+                return 0;
+        else
+                return -1;
+}
+
+static int au1xxxide_pm_idle( au1xxx_power_dev_t *dev ) {
+        return 0;
+}
+
+static int au1xxxide_pm_cleanup( au1xxx_power_dev_t *dev ) {
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("AU1200 IDE driver");
+
+module_init(au_ide_init);
+module_exit(au_ide_exit);
diff --git a/drivers/ide/ppc/pmac.c b/drivers/ide/ppc/pmac.c
index 87d1f8a1f41e..d8c3d8ebad30 100644
--- a/drivers/ide/ppc/pmac.c
+++ b/drivers/ide/ppc/pmac.c
@@ -81,7 +81,7 @@ typedef struct pmac_ide_hwif {
         
 } pmac_ide_hwif_t;
 
-static pmac_ide_hwif_t pmac_ide[MAX_HWIFS] __pmacdata;
+static pmac_ide_hwif_t pmac_ide[MAX_HWIFS];
 static int pmac_ide_count;
 
 enum {
@@ -242,7 +242,7 @@ struct mdma_timings_t {
         int     cycleTime;
 };
 
-struct mdma_timings_t mdma_timings_33[] __pmacdata =
+struct mdma_timings_t mdma_timings_33[] =
 {
     { 240, 240, 480 },
     { 180, 180, 360 },
@@ -255,7 +255,7 @@ struct mdma_timings_t mdma_timings_33[] __pmacdata =
     {   0,   0,   0 }
 };
 
-struct mdma_timings_t mdma_timings_33k[] __pmacdata =
+struct mdma_timings_t mdma_timings_33k[] =
 {
     { 240, 240, 480 },
     { 180, 180, 360 },
@@ -268,7 +268,7 @@ struct mdma_timings_t mdma_timings_33k[] __pmacdata =
     {   0,   0,   0 }
 };
 
-struct mdma_timings_t mdma_timings_66[] __pmacdata =
+struct mdma_timings_t mdma_timings_66[] =
 {
     { 240, 240, 480 },
     { 180, 180, 360 },
@@ -286,7 +286,7 @@ struct {
         int     addrSetup; /* ??? */
         int     rdy2pause;
         int     wrDataSetup;
-} kl66_udma_timings[] __pmacdata =
+} kl66_udma_timings[] =
 {
     {   0, 180,  120 }, /* Mode 0 */
     {   0, 150,  90 },  /*      1 */
@@ -301,7 +301,7 @@ struct kauai_timing {
         u32     timing_reg;
 };
 
-static struct kauai_timing      kauai_pio_timings[] __pmacdata =
+static struct kauai_timing      kauai_pio_timings[] =
 {
         { 930   , 0x08000fff },
         { 600   , 0x08000a92 },
@@ -316,7 +316,7 @@ static struct kauai_timing	kauai_pio_timings[] __pmacdata =
         { 120   , 0x04000148 }
 };
 
-static struct kauai_timing      kauai_mdma_timings[] __pmacdata =
+static struct kauai_timing      kauai_mdma_timings[] =
 {
         { 1260  , 0x00fff000 },
         { 480   , 0x00618000 },
@@ -330,7 +330,7 @@ static struct kauai_timing	kauai_mdma_timings[] __pmacdata =
         { 0     , 0 },
 };
 
-static struct kauai_timing      kauai_udma_timings[] __pmacdata =
+static struct kauai_timing      kauai_udma_timings[] =
 {
         { 120   , 0x000070c0 },
         { 90    , 0x00005d80 },
@@ -341,7 +341,7 @@ static struct kauai_timing	kauai_udma_timings[] __pmacdata =
         { 0     , 0 },
 };
 
-static struct kauai_timing      shasta_pio_timings[] __pmacdata =
+static struct kauai_timing      shasta_pio_timings[] =
 {
         { 930   , 0x08000fff },
         { 600   , 0x0A000c97 },
@@ -356,7 +356,7 @@ static struct kauai_timing	shasta_pio_timings[] __pmacdata =
         { 120   , 0x0400010a }
 };
 
-static struct kauai_timing      shasta_mdma_timings[] __pmacdata =
+static struct kauai_timing      shasta_mdma_timings[] =
 {
         { 1260  , 0x00fff000 },
         { 480   , 0x00820800 },
@@ -370,7 +370,7 @@ static struct kauai_timing	shasta_mdma_timings[] __pmacdata =
         { 0     , 0 },
 };
 
-static struct kauai_timing      shasta_udma133_timings[] __pmacdata =
+static struct kauai_timing      shasta_udma133_timings[] =
 {
         { 120   , 0x00035901, },
         { 90    , 0x000348b1, },
@@ -522,7 +522,7 @@ pmu_hd_blink_init(void)
  * N.B. this can't be an initfunc, because the media-bay task can
  * call ide_[un]register at any time.
  */
-void __pmac
+void
 pmac_ide_init_hwif_ports(hw_regs_t *hw,
                               unsigned long data_port, unsigned long ctrl_port,
                               int *irq)
@@ -559,7 +559,7 @@ pmac_ide_init_hwif_ports(hw_regs_t *hw,
  * timing register when selecting that unit. This version is for
  * ASICs with a single timing register
  */
-static void __pmac
+static void
 pmac_ide_selectproc(ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -579,7 +579,7 @@ pmac_ide_selectproc(ide_drive_t *drive)
  * timing register when selecting that unit. This version is for
  * ASICs with a dual timing register (Kauai)
  */
-static void __pmac
+static void
 pmac_ide_kauai_selectproc(ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -600,7 +600,7 @@ pmac_ide_kauai_selectproc(ide_drive_t *drive)
 /*
  * Force an update of controller timing values for a given drive
  */
-static void __pmac
+static void
 pmac_ide_do_update_timings(ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -633,7 +633,7 @@ pmac_outbsync(ide_drive_t *drive, u8 value, unsigned long port)
  * to sort that out sooner or later and see if I can finally get the
  * common version to work properly in all cases
  */
-static int __pmac
+static int
 pmac_ide_do_setfeature(ide_drive_t *drive, u8 command)
 {
         ide_hwif_t *hwif = HWIF(drive);
@@ -710,7 +710,7 @@ out:
 /*
  * Old tuning functions (called on hdparm -p), sets up drive PIO timings
  */
-static void __pmac
+static void
 pmac_ide_tuneproc(ide_drive_t *drive, u8 pio)
 {
         ide_pio_data_t d;
@@ -801,7 +801,7 @@ pmac_ide_tuneproc(ide_drive_t *drive, u8 pio)
 /*
  * Calculate KeyLargo ATA/66 UDMA timings
  */
-static int __pmac
+static int
 set_timings_udma_ata4(u32 *timings, u8 speed)
 {
         unsigned rdyToPauseTicks, wrDataSetupTicks, addrTicks;
@@ -829,7 +829,7 @@ set_timings_udma_ata4(u32 *timings, u8 speed)
 /*
  * Calculate Kauai ATA/100 UDMA timings
  */
-static int __pmac
+static int
 set_timings_udma_ata6(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 {
         struct ide_timing *t = ide_timing_find_mode(speed);
@@ -849,7 +849,7 @@ set_timings_udma_ata6(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 /*
  * Calculate Shasta ATA/133 UDMA timings
  */
-static int __pmac
+static int
 set_timings_udma_shasta(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 {
         struct ide_timing *t = ide_timing_find_mode(speed);
@@ -869,7 +869,7 @@ set_timings_udma_shasta(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 /*
  * Calculate MDMA timings for all cells
  */
-static int __pmac
+static int
 set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
                         u8 speed, int drive_cycle_time)
 {
@@ -1014,7 +1014,7 @@ set_timings_mdma(ide_drive_t *drive, int intf_type, u32 *timings, u32 *timings2,
  * our dedicated function is more precise as it uses the drive provided
  * cycle time value. We should probably fix this one to deal with that too...
  */
-static int __pmac
+static int
 pmac_ide_tune_chipset (ide_drive_t *drive, byte speed)
 {
         int unit = (drive->select.b.unit & 0x01);
@@ -1092,7 +1092,7 @@ pmac_ide_tune_chipset (ide_drive_t *drive, byte speed)
  * Blast some well known "safe" values to the timing registers at init or
  * wakeup from sleep time, before we do real calculation
  */
-static void __pmac
+static void
 sanitize_timings(pmac_ide_hwif_t *pmif)
 {
         unsigned int value, value2 = 0;
@@ -1123,13 +1123,13 @@ sanitize_timings(pmac_ide_hwif_t *pmif)
         pmif->timings[2] = pmif->timings[3] = value2;
 }
 
-unsigned long __pmac
+unsigned long
 pmac_ide_get_base(int index)
 {
         return pmac_ide[index].regbase;
 }
 
-int __pmac
+int
 pmac_ide_check_base(unsigned long base)
 {
         int ix;
@@ -1140,7 +1140,7 @@ pmac_ide_check_base(unsigned long base)
         return -1;
 }
 
-int __pmac
+int
 pmac_ide_get_irq(unsigned long base)
 {
         int ix;
@@ -1151,7 +1151,7 @@ pmac_ide_get_irq(unsigned long base)
         return 0;
 }
 
-static int ide_majors[]  __pmacdata = { 3, 22, 33, 34, 56, 57 };
+static int ide_majors[] = { 3, 22, 33, 34, 56, 57 };
 
 dev_t __init
 pmac_find_ide_boot(char *bootdevice, int n)
@@ -1701,7 +1701,7 @@ pmac_ide_probe(void)
  * pmac_ide_build_dmatable builds the DBDMA command list
  * for a transfer and sets the DBDMA channel to point to it.
  */
-static int __pmac
+static int
 pmac_ide_build_dmatable(ide_drive_t *drive, struct request *rq)
 {
         struct dbdma_cmd *table;
@@ -1785,7 +1785,7 @@ pmac_ide_build_dmatable(ide_drive_t *drive, struct request *rq)
 }
 
 /* Teardown mappings after DMA has completed.  */
-static void __pmac
+static void
 pmac_ide_destroy_dmatable (ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
@@ -1802,7 +1802,7 @@ pmac_ide_destroy_dmatable (ide_drive_t *drive)
 /*
  * Pick up best MDMA timing for the drive and apply it
  */
-static int __pmac
+static int
 pmac_ide_mdma_enable(ide_drive_t *drive, u16 mode)
 {
         ide_hwif_t *hwif = HWIF(drive);
@@ -1859,7 +1859,7 @@ pmac_ide_mdma_enable(ide_drive_t *drive, u16 mode)
 /*
  * Pick up best UDMA timing for the drive and apply it
  */
-static int __pmac
+static int
 pmac_ide_udma_enable(ide_drive_t *drive, u16 mode)
 {
         ide_hwif_t *hwif = HWIF(drive);
@@ -1915,7 +1915,7 @@ pmac_ide_udma_enable(ide_drive_t *drive, u16 mode)
  * Check what is the best DMA timing setting for the drive and
  * call appropriate functions to apply it.
  */
-static int __pmac
+static int
 pmac_ide_dma_check(ide_drive_t *drive)
 {
         struct hd_driveid *id = drive->id;
@@ -1967,7 +1967,7 @@ pmac_ide_dma_check(ide_drive_t *drive)
  * Prepare a DMA transfer. We build the DMA table, adjust the timings for
  * a read on KeyLargo ATA/66 and mark us as waiting for DMA completion
  */
-static int __pmac
+static int
 pmac_ide_dma_setup(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = HWIF(drive);
@@ -1997,7 +1997,7 @@ pmac_ide_dma_setup(ide_drive_t *drive)
         return 0;
 }
 
-static void __pmac
+static void
 pmac_ide_dma_exec_cmd(ide_drive_t *drive, u8 command)
 {
         /* issue cmd to drive */
@@ -2008,7 +2008,7 @@ pmac_ide_dma_exec_cmd(ide_drive_t *drive, u8 command)
  * Kick the DMA controller into life after the DMA command has been issued
  * to the drive.
  */
-static void __pmac
+static void
 pmac_ide_dma_start(ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -2024,7 +2024,7 @@ pmac_ide_dma_start(ide_drive_t *drive)
 /*
  * After a DMA transfer, make sure the controller is stopped
  */
-static int __pmac
+static int
 pmac_ide_dma_end (ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -2052,7 +2052,7 @@ pmac_ide_dma_end (ide_drive_t *drive)
  * that's not implemented yet), on the other hand, we don't have shared interrupts
  * so it's not really a problem
  */
-static int __pmac
+static int
 pmac_ide_dma_test_irq (ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
@@ -2108,19 +2108,19 @@ pmac_ide_dma_test_irq (ide_drive_t *drive)
         return 1;
 }
 
-static int __pmac
+static int
 pmac_ide_dma_host_off (ide_drive_t *drive)
 {
         return 0;
 }
 
-static int __pmac
+static int
 pmac_ide_dma_host_on (ide_drive_t *drive)
 {
         return 0;
 }
 
-static int __pmac
+static int
 pmac_ide_dma_lostirq (ide_drive_t *drive)
 {
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
diff --git a/drivers/infiniband/core/agent.h b/drivers/infiniband/core/agent.h
index c5f3cfec942a..86d72fab37b0 100644
--- a/drivers/infiniband/core/agent.h
+++ b/drivers/infiniband/core/agent.h
@@ -39,6 +39,7 @@
 #ifndef __AGENT_H_
 #define __AGENT_H_
 
+#include <linux/err.h>
 #include <rdma/ib_mad.h>
 
 extern int ib_agent_port_open(struct ib_device *device, int port_num);
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index f014e639088c..c57a3871184c 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -38,6 +38,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
+#include <linux/sched.h>        /* INIT_WORK, schedule_work(), flush_scheduled_work() */
 
 #include <rdma/ib_cache.h>
 
diff --git a/drivers/infiniband/core/sa_query.c b/drivers/infiniband/core/sa_query.c
index 89ce9dc210d4..acda7d63d6fe 100644
--- a/drivers/infiniband/core/sa_query.c
+++ b/drivers/infiniband/core/sa_query.c
@@ -43,6 +43,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/kref.h>
 #include <linux/idr.h>
+#include <linux/workqueue.h>
 
 #include <rdma/ib_pack.h>
 #include <rdma/ib_sa.h>
diff --git a/drivers/infiniband/hw/mthca/mthca_av.c b/drivers/infiniband/hw/mthca/mthca_av.c
index 889e85096736..22fdc446f25c 100644
--- a/drivers/infiniband/hw/mthca/mthca_av.c
+++ b/drivers/infiniband/hw/mthca/mthca_av.c
@@ -34,6 +34,8 @@
  */
 
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_cache.h>
diff --git a/drivers/infiniband/hw/mthca/mthca_mad.c b/drivers/infiniband/hw/mthca/mthca_mad.c
index 8561b297a19b..1229c604c6e0 100644
--- a/drivers/infiniband/hw/mthca/mthca_mad.c
+++ b/drivers/infiniband/hw/mthca/mthca_mad.c
@@ -34,6 +34,9 @@
  * $Id: mthca_mad.c 1349 2004-12-16 21:09:43Z roland $
  */
 
+#include <linux/string.h>
+#include <linux/slab.h>
+
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_mad.h>
 #include <rdma/ib_smi.h>
diff --git a/drivers/infiniband/hw/mthca/mthca_mcg.c b/drivers/infiniband/hw/mthca/mthca_mcg.c
index b47ea7daf088..2fc449da418d 100644
--- a/drivers/infiniband/hw/mthca/mthca_mcg.c
+++ b/drivers/infiniband/hw/mthca/mthca_mcg.c
@@ -33,6 +33,8 @@
  */
 
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "mthca_dev.h"
 #include "mthca_cmd.h"
diff --git a/drivers/infiniband/hw/mthca/mthca_profile.c b/drivers/infiniband/hw/mthca/mthca_profile.c
index 0576056b34f4..bd1338682074 100644
--- a/drivers/infiniband/hw/mthca/mthca_profile.c
+++ b/drivers/infiniband/hw/mthca/mthca_profile.c
@@ -35,6 +35,8 @@
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "mthca_profile.h"
 
diff --git a/drivers/infiniband/hw/mthca/mthca_qp.c b/drivers/infiniband/hw/mthca/mthca_qp.c
index 62ff091505da..7c9afde5ace5 100644
--- a/drivers/infiniband/hw/mthca/mthca_qp.c
+++ b/drivers/infiniband/hw/mthca/mthca_qp.c
@@ -36,6 +36,8 @@
  */
 
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_cache.h>
diff --git a/drivers/infiniband/hw/mthca/mthca_reset.c b/drivers/infiniband/hw/mthca/mthca_reset.c
index 4f995391dd1d..df5e494a9d38 100644
--- a/drivers/infiniband/hw/mthca/mthca_reset.c
+++ b/drivers/infiniband/hw/mthca/mthca_reset.c
@@ -37,6 +37,7 @@
 #include <linux/errno.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include "mthca_dev.h"
 #include "mthca_cmd.h"
diff --git a/drivers/infiniband/hw/mthca/mthca_uar.c b/drivers/infiniband/hw/mthca/mthca_uar.c
index 1c8791ded6ff..8e9219842be4 100644
--- a/drivers/infiniband/hw/mthca/mthca_uar.c
+++ b/drivers/infiniband/hw/mthca/mthca_uar.c
@@ -32,6 +32,8 @@
  * $Id$
  */
 
+#include <asm/page.h>           /* PAGE_SHIFT */
+
 #include "mthca_dev.h"
 #include "mthca_memfree.h"
 
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index a4696cd0978c..9f2352bd8348 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -565,6 +565,7 @@ static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned lon
                                                 case EV_LED: bits = dev->ledbit; max = LED_MAX; break;
                                                 case EV_SND: bits = dev->sndbit; max = SND_MAX; break;
                                                 case EV_FF:  bits = dev->ffbit;  max = FF_MAX;  break;
+                                                case EV_SW:  bits = dev->swbit;  max = SW_MAX;  break;
                                                 default: return -EINVAL;
                                         }
                                         bit_to_user(bits, max);
@@ -579,6 +580,9 @@ static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned lon
                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))
                                         bit_to_user(dev->snd, SND_MAX);
 
+                                if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))
+                                        bit_to_user(dev->sw, SW_MAX);
+
                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
                                         int len;
                                         if (!dev->name) return -ENOENT;
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index ab09cf4093e3..0506934244f0 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/sched.h>        /* HZ */
 
 /*#include <asm/io.h>*/
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 3b1685ff9d10..1a1654caedd5 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -730,7 +730,7 @@ static void input_register_classdevice(struct input_dev *dev)
                  "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
 
         path = kobject_get_path(&dev->cdev.class->subsys.kset.kobj, GFP_KERNEL);
-        printk(KERN_INFO "input: %s/%s as %s\n",
+        printk(KERN_INFO "input: %s as %s/%s\n",
                 dev->name ? dev->name : "Unspecified device",
                 path ? path : "", dev->cdev.class_id);
         kfree(path);
diff --git a/drivers/input/joystick/a3d.c b/drivers/input/joystick/a3d.c
index bf65430181fa..4571ea3a4b92 100644
--- a/drivers/input/joystick/a3d.c
+++ b/drivers/input/joystick/a3d.c
@@ -34,6 +34,7 @@
 #include <linux/init.h>
 #include <linux/gameport.h>
 #include <linux/input.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "FP-Gaming Assasin 3D joystick driver"
 
diff --git a/drivers/input/joystick/adi.c b/drivers/input/joystick/adi.c
index 9d95459f4bcb..704bf70f1db7 100644
--- a/drivers/input/joystick/adi.c
+++ b/drivers/input/joystick/adi.c
@@ -34,6 +34,7 @@
 #include <linux/input.h>
 #include <linux/gameport.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Logitech ADI joystick family driver"
 
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index c75ac6eb1ffb..3121961e3e7c 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -38,6 +38,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/gameport.h>
+#include <linux/jiffies.h>
 #include <asm/timex.h>
 
 #define DRIVER_DESC     "Analog joystick and gamepad driver"
diff --git a/drivers/input/joystick/cobra.c b/drivers/input/joystick/cobra.c
index 9a3dfc724a41..1909f7ef340c 100644
--- a/drivers/input/joystick/cobra.c
+++ b/drivers/input/joystick/cobra.c
@@ -34,6 +34,7 @@
 #include <linux/init.h>
 #include <linux/gameport.h>
 #include <linux/input.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Creative Labs Blaster GamePad Cobra driver"
 
diff --git a/drivers/input/joystick/gf2k.c b/drivers/input/joystick/gf2k.c
index e151f8c5bcb9..8a3ad455eb38 100644
--- a/drivers/input/joystick/gf2k.c
+++ b/drivers/input/joystick/gf2k.c
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/gameport.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Genius Flight 2000 joystick driver"
 
diff --git a/drivers/input/joystick/grip.c b/drivers/input/joystick/grip.c
index e206bb56e53c..a936e7aedb10 100644
--- a/drivers/input/joystick/grip.c
+++ b/drivers/input/joystick/grip.c
@@ -34,6 +34,7 @@
 #include <linux/slab.h>
 #include <linux/gameport.h>
 #include <linux/input.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Gravis GrIP protocol joystick driver"
 
diff --git a/drivers/input/joystick/grip_mp.c b/drivers/input/joystick/grip_mp.c
index a0ba93ccac72..51a912222e85 100644
--- a/drivers/input/joystick/grip_mp.c
+++ b/drivers/input/joystick/grip_mp.c
@@ -19,6 +19,7 @@
 #include <linux/input.h>
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Gravis Grip Multiport driver"
 
diff --git a/drivers/input/joystick/guillemot.c b/drivers/input/joystick/guillemot.c
index c528473c09d8..6e2c721c26ba 100644
--- a/drivers/input/joystick/guillemot.c
+++ b/drivers/input/joystick/guillemot.c
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/gameport.h>
 #include <linux/input.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Guillemot Digital joystick driver"
 
diff --git a/drivers/input/joystick/interact.c b/drivers/input/joystick/interact.c
index 8511ee7bb263..c4ed01758226 100644
--- a/drivers/input/joystick/interact.c
+++ b/drivers/input/joystick/interact.c
@@ -38,6 +38,7 @@
 #include <linux/init.h>
 #include <linux/gameport.h>
 #include <linux/input.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "InterAct digital joystick driver"
 
diff --git a/drivers/input/joystick/joydump.c b/drivers/input/joystick/joydump.c
index 4234ccaf9146..88ec5a918f2e 100644
--- a/drivers/input/joystick/joydump.c
+++ b/drivers/input/joystick/joydump.c
@@ -34,6 +34,7 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #define DRIVER_DESC     "Gameport data dumper module"
 
diff --git a/drivers/input/joystick/sidewinder.c b/drivers/input/joystick/sidewinder.c
index eaaad45cc750..78dd163cd702 100644
--- a/drivers/input/joystick/sidewinder.c
+++ b/drivers/input/joystick/sidewinder.c
@@ -33,6 +33,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/gameport.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "Microsoft SideWinder joystick family driver"
 
diff --git a/drivers/input/joystick/tmdc.c b/drivers/input/joystick/tmdc.c
index 3a7d1bb46472..60e2aac7d06e 100644
--- a/drivers/input/joystick/tmdc.c
+++ b/drivers/input/joystick/tmdc.c
@@ -38,6 +38,7 @@
 #include <linux/init.h>
 #include <linux/gameport.h>
 #include <linux/input.h>
+#include <linux/jiffies.h>
 
 #define DRIVER_DESC     "ThrustMaster DirectConnect joystick driver"
 
diff --git a/drivers/input/keyboard/amikbd.c b/drivers/input/keyboard/amikbd.c
index 3d63bc1ad322..4c8fb1f8631f 100644
--- a/drivers/input/keyboard/amikbd.c
+++ b/drivers/input/keyboard/amikbd.c
@@ -199,7 +199,7 @@ static int __init amikbd_init(void)
         if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb"))
                 return -EBUSY;
 
-        amikbd_dev = input_dev_allocate();
+        amikbd_dev = input_allocate_device();
         if (!amikbd_dev) {
                 printk(KERN_ERR "amikbd: not enough memory for input device\n");
                 release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);
diff --git a/drivers/input/keyboard/lkkbd.c b/drivers/input/keyboard/lkkbd.c
index 7f06780a437f..9481132532d0 100644
--- a/drivers/input/keyboard/lkkbd.c
+++ b/drivers/input/keyboard/lkkbd.c
@@ -441,7 +441,7 @@ lkkbd_interrupt (struct serio *serio, unsigned char data, unsigned int flags,
                         input_sync (lk->dev);
                         break;
                 case LK_METRONOME:
-                        DBG (KERN_INFO "Got %#d and don't "
+                        DBG (KERN_INFO "Got LK_METRONOME and don't "
                                         "know how to handle...\n");
                         break;
                 case LK_OUTPUT_ERROR:
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index bb934e6d9636..b3eaac1b35b6 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -14,7 +14,7 @@ if INPUT_MISC
 
 config INPUT_PCSPKR
         tristate "PC Speaker support"
-        depends on ALPHA || X86 || X86_64 || MIPS || PPC_PREP || PPC_CHRP || PPC_PSERIES
+        depends on ALPHA || X86 || MIPS || PPC_PREP || PPC_CHRP || PPC_PSERIES
         help
           Say Y here if you want the standard PC Speaker to be used for
           bells and whistles.
diff --git a/drivers/input/misc/pcspkr.c b/drivers/input/misc/pcspkr.c
index e34633c37fdd..68ac97f101b0 100644
--- a/drivers/input/misc/pcspkr.c
+++ b/drivers/input/misc/pcspkr.c
@@ -71,7 +71,7 @@ static int __init pcspkr_init(void)
                 return -ENOMEM;
 
         pcspkr_dev->name = "PC Speaker";
-        pcspkr_dev->name = "isa0061/input0";
+        pcspkr_dev->phys = "isa0061/input0";
         pcspkr_dev->id.bustype = BUS_ISA;
         pcspkr_dev->id.vendor = 0x001f;
         pcspkr_dev->id.product = 0x0001;
diff --git a/drivers/input/misc/sparcspkr.c b/drivers/input/misc/sparcspkr.c
index 5778220a18d2..29d97b12be7a 100644
--- a/drivers/input/misc/sparcspkr.c
+++ b/drivers/input/misc/sparcspkr.c
@@ -143,7 +143,7 @@ static int __init init_isa_beep(struct sparc_isa_device *isa_dev)
         sparcspkr_dev->name = "Sparc ISA Speaker";
         sparcspkr_dev->event = isa_spkr_event;
 
-        input_register_device(&sparcspkr_dev);
+        input_register_device(sparcspkr_dev);
 
         return 0;
 }
diff --git a/drivers/input/serio/hp_sdc_mlc.c b/drivers/input/serio/hp_sdc_mlc.c
index e3c44ffae674..1c9426fd5205 100644
--- a/drivers/input/serio/hp_sdc_mlc.c
+++ b/drivers/input/serio/hp_sdc_mlc.c
@@ -40,6 +40,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/string.h>
+#include <asm/semaphore.h>
 
 #define PREFIX "HP SDC MLC: "
 
diff --git a/drivers/isdn/capi/capifs.c b/drivers/isdn/capi/capifs.c
index 3abd7fc6e5ef..7b564c0dd996 100644
--- a/drivers/isdn/capi/capifs.c
+++ b/drivers/isdn/capi/capifs.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/ctype.h>
+#include <linux/sched.h>        /* current */
 
 MODULE_DESCRIPTION("CAPI4Linux: /dev/capi/ filesystem");
 MODULE_AUTHOR("Carsten Paeth");
diff --git a/drivers/isdn/hisax/hfc4s8s_l1.c b/drivers/isdn/hisax/hfc4s8s_l1.c
index 7333377ab31d..e3866b0a97fd 100644
--- a/drivers/isdn/hisax/hfc4s8s_l1.c
+++ b/drivers/isdn/hisax/hfc4s8s_l1.c
@@ -1063,7 +1063,7 @@ tx_b_frame(struct hfc4s8s_btype *bch)
                                 Write_hfc8(l1->hw, A_INC_RES_FIFO, 1);
                         }
                         ack_len += skb->truesize;
-                        bch->tx_skb = 0;
+                        bch->tx_skb = NULL;
                         bch->tx_cnt = 0;
                         dev_kfree_skb(skb);
                 } else
@@ -1659,10 +1659,10 @@ hfc4s8s_remove(struct pci_dev *pdev)
 }
 
 static struct pci_driver hfc4s8s_driver = {
-      name:"hfc4s8s_l1",
-      probe:hfc4s8s_probe,
-      remove:__devexit_p(hfc4s8s_remove),
-      id_table:hfc4s8s_ids,
+      .name     = "hfc4s8s_l1",
+      .probe    = hfc4s8s_probe,
+      .remove   = __devexit_p(hfc4s8s_remove),
+      .id_table = hfc4s8s_ids,
 };
 
 /**********************/
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index cdb6d0283195..8f02c155fdc0 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -723,6 +723,7 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
 
         sprintf(hid->phys, "adb%d:%d.%02x/input", id, default_id, original_handler_id);
 
+        hid->input = input_dev;
         hid->id = default_id;
         hid->original_handler_id = original_handler_id;
         hid->current_handler_id = current_handler_id;
diff --git a/drivers/macintosh/ans-lcd.c b/drivers/macintosh/ans-lcd.c
index 5e0811dc6536..2b8a6e821d44 100644
--- a/drivers/macintosh/ans-lcd.c
+++ b/drivers/macintosh/ans-lcd.c
@@ -27,7 +27,7 @@ static volatile unsigned char __iomem *anslcd_ptr;
 
 #undef DEBUG
 
-static void __pmac
+static void
 anslcd_write_byte_ctrl ( unsigned char c )
 {
 #ifdef DEBUG
@@ -43,14 +43,14 @@ anslcd_write_byte_ctrl ( unsigned char c )
         }
 }
 
-static void __pmac
+static void
 anslcd_write_byte_data ( unsigned char c )
 {
         out_8(anslcd_ptr + ANSLCD_DATA_IX, c);
         udelay(anslcd_short_delay);
 }
 
-static ssize_t __pmac
+static ssize_t
 anslcd_write( struct file * file, const char __user * buf, 
                                 size_t count, loff_t *ppos )
 {
@@ -73,7 +73,7 @@ anslcd_write( struct file * file, const char __user * buf,
         return p - buf;
 }
 
-static int __pmac
+static int
 anslcd_ioctl( struct inode * inode, struct file * file,
                                 unsigned int cmd, unsigned long arg )
 {
@@ -115,7 +115,7 @@ anslcd_ioctl( struct inode * inode, struct file * file,
         }
 }
 
-static int __pmac
+static int
 anslcd_open( struct inode * inode, struct file * file )
 {
         return 0;
diff --git a/drivers/macintosh/apm_emu.c b/drivers/macintosh/apm_emu.c
index 19d3e05d6825..e5a2bbf99399 100644
--- a/drivers/macintosh/apm_emu.c
+++ b/drivers/macintosh/apm_emu.c
@@ -430,8 +430,8 @@ static int apm_emu_get_info(char *buf, char **start, off_t fpos, int length)
               -1: Unknown
            8) min = minutes; sec = seconds */
 
-        unsigned short  ac_line_status = 0xff;
-        unsigned short  battery_status = 0xff;
+        unsigned short  ac_line_status;
+        unsigned short  battery_status = 0;
         unsigned short  battery_flag   = 0xff;
         int             percentage     = -1;
         int             time_units     = -1;
@@ -446,6 +446,7 @@ static int apm_emu_get_info(char *buf, char **start, off_t fpos, int length)
         ac_line_status = ((pmu_power_flags & PMU_PWR_AC_PRESENT) != 0);
         for (i=0; i<pmu_battery_count; i++) {
                 if (pmu_batteries[i].flags & PMU_BATT_PRESENT) {
+                        battery_status++;
                         if (percentage < 0)
                                 percentage = 0;
                         if (charge < 0)
@@ -461,6 +462,9 @@ static int apm_emu_get_info(char *buf, char **start, off_t fpos, int length)
                                 charging++;
                 }
         }
+        if (0 == battery_status)
+                ac_line_status = 1;
+        battery_status = 0xff;
         if (real_count) {
                 if (amperage < 0) {
                         if (btype == PMU_BATT_TYPE_SMART)
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 1ee003346923..c34c96d18907 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -17,6 +17,8 @@
 #include <linux/pci_ids.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
+
 #include <asm/machdep.h>
 #include <asm/macio.h>
 #include <asm/pmac_feature.h>
diff --git a/drivers/macintosh/macio_sysfs.c b/drivers/macintosh/macio_sysfs.c
index 97d22bb4516a..7f7d4eaca870 100644
--- a/drivers/macintosh/macio_sysfs.c
+++ b/drivers/macintosh/macio_sysfs.c
@@ -39,6 +39,31 @@ compatible_show (struct device *dev, struct device_attribute *attr, char *buf)
         return length;
 }
 
+static ssize_t modalias_show (struct device *dev, struct device_attribute *attr,
+                              char *buf)
+{
+        struct of_device *of;
+        char *compat;
+        int cplen;
+        int length;
+
+        of = &to_macio_device (dev)->ofdev;
+        compat = (char *) get_property (of->node, "compatible", &cplen);
+        if (!compat) compat = "", cplen = 1;
+        length = sprintf (buf, "of:N%sT%s", of->node->name, of->node->type);
+        buf += length;
+        while (cplen > 0) {
+                int l;
+                length += sprintf (buf, "C%s", compat);
+                buf += length;
+                l = strlen (compat) + 1;
+                compat += l;
+                cplen -= l;
+        }
+
+        return length;
+}
+
 macio_config_of_attr (name, "%s\n");
 macio_config_of_attr (type, "%s\n");
 
@@ -46,5 +71,6 @@ struct device_attribute macio_dev_attrs[] = {
         __ATTR_RO(name),
         __ATTR_RO(type),
         __ATTR_RO(compatible),
+        __ATTR_RO(modalias),
         __ATTR_NULL
 };
diff --git a/drivers/macintosh/mediabay.c b/drivers/macintosh/mediabay.c
index c0712a1ea5af..b856bb67169c 100644
--- a/drivers/macintosh/mediabay.c
+++ b/drivers/macintosh/mediabay.c
@@ -167,19 +167,19 @@ enum {
  * Functions for polling content of media bay
  */
  
-static u8 __pmac
+static u8
 ohare_mb_content(struct media_bay_info *bay)
 {
         return (MB_IN32(bay, OHARE_MBCR) >> 12) & 7;
 }
 
-static u8 __pmac
+static u8
 heathrow_mb_content(struct media_bay_info *bay)
 {
         return (MB_IN32(bay, HEATHROW_MBCR) >> 12) & 7;
 }
 
-static u8 __pmac
+static u8
 keylargo_mb_content(struct media_bay_info *bay)
 {
         int new_gpio;
@@ -205,7 +205,7 @@ keylargo_mb_content(struct media_bay_info *bay)
  * into reset state as well
  */
 
-static void __pmac
+static void
 ohare_mb_power(struct media_bay_info* bay, int on_off)
 {
         if (on_off) {
@@ -224,7 +224,7 @@ ohare_mb_power(struct media_bay_info* bay, int on_off)
         MB_BIC(bay, OHARE_MBCR, 0x00000F00);
 }
 
-static void __pmac
+static void
 heathrow_mb_power(struct media_bay_info* bay, int on_off)
 {
         if (on_off) {
@@ -243,7 +243,7 @@ heathrow_mb_power(struct media_bay_info* bay, int on_off)
         MB_BIC(bay, HEATHROW_MBCR, 0x00000F00);
 }
 
-static void __pmac
+static void
 keylargo_mb_power(struct media_bay_info* bay, int on_off)
 {
         if (on_off) {
@@ -267,7 +267,7 @@ keylargo_mb_power(struct media_bay_info* bay, int on_off)
  * enable the related busses
  */
 
-static int __pmac
+static int
 ohare_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
 {
         switch(device_id) {
@@ -287,7 +287,7 @@ ohare_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
         return -ENODEV;
 }
 
-static int __pmac
+static int
 heathrow_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
 {
         switch(device_id) {
@@ -307,7 +307,7 @@ heathrow_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
         return -ENODEV;
 }
 
-static int __pmac
+static int
 keylargo_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
 {
         switch(device_id) {
@@ -330,43 +330,43 @@ keylargo_mb_setup_bus(struct media_bay_info* bay, u8 device_id)
  * Functions for tweaking resets
  */
 
-static void __pmac
+static void
 ohare_mb_un_reset(struct media_bay_info* bay)
 {
         MB_BIS(bay, OHARE_FCR, OH_BAY_RESET_N);
 }
 
-static void __pmac keylargo_mb_init(struct media_bay_info *bay)
+static void keylargo_mb_init(struct media_bay_info *bay)
 {
         MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_ENABLE);
 }
 
-static void __pmac heathrow_mb_un_reset(struct media_bay_info* bay)
+static void heathrow_mb_un_reset(struct media_bay_info* bay)
 {
         MB_BIS(bay, HEATHROW_FCR, HRW_BAY_RESET_N);
 }
 
-static void __pmac keylargo_mb_un_reset(struct media_bay_info* bay)
+static void keylargo_mb_un_reset(struct media_bay_info* bay)
 {
         MB_BIS(bay, KEYLARGO_MBCR, KL_MBCR_MB0_DEV_RESET);
 }
 
-static void __pmac ohare_mb_un_reset_ide(struct media_bay_info* bay)
+static void ohare_mb_un_reset_ide(struct media_bay_info* bay)
 {
         MB_BIS(bay, OHARE_FCR, OH_IDE1_RESET_N);
 }
 
-static void __pmac heathrow_mb_un_reset_ide(struct media_bay_info* bay)
+static void heathrow_mb_un_reset_ide(struct media_bay_info* bay)
 {
         MB_BIS(bay, HEATHROW_FCR, HRW_IDE1_RESET_N);
 }
 
-static void __pmac keylargo_mb_un_reset_ide(struct media_bay_info* bay)
+static void keylargo_mb_un_reset_ide(struct media_bay_info* bay)
 {
         MB_BIS(bay, KEYLARGO_FCR1, KL1_EIDE0_RESET_N);
 }
 
-static inline void __pmac set_mb_power(struct media_bay_info* bay, int onoff)
+static inline void set_mb_power(struct media_bay_info* bay, int onoff)
 {
         /* Power up up and assert the bay reset line */
         if (onoff) {
@@ -382,7 +382,7 @@ static inline void __pmac set_mb_power(struct media_bay_info* bay, int onoff)
         bay->timer = msecs_to_jiffies(MB_POWER_DELAY);
 }
 
-static void __pmac poll_media_bay(struct media_bay_info* bay)
+static void poll_media_bay(struct media_bay_info* bay)
 {
         int id = bay->ops->content(bay);
 
@@ -415,7 +415,7 @@ static void __pmac poll_media_bay(struct media_bay_info* bay)
         }
 }
 
-int __pmac check_media_bay(struct device_node *which_bay, int what)
+int check_media_bay(struct device_node *which_bay, int what)
 {
 #ifdef CONFIG_BLK_DEV_IDE
         int     i;
@@ -432,7 +432,7 @@ int __pmac check_media_bay(struct device_node *which_bay, int what)
 }
 EXPORT_SYMBOL(check_media_bay);
 
-int __pmac check_media_bay_by_base(unsigned long base, int what)
+int check_media_bay_by_base(unsigned long base, int what)
 {
 #ifdef CONFIG_BLK_DEV_IDE
         int     i;
@@ -449,7 +449,7 @@ int __pmac check_media_bay_by_base(unsigned long base, int what)
         return -ENODEV;
 }
 
-int __pmac media_bay_set_ide_infos(struct device_node* which_bay, unsigned long base,
+int media_bay_set_ide_infos(struct device_node* which_bay, unsigned long base,
         int irq, int index)
 {
 #ifdef CONFIG_BLK_DEV_IDE
@@ -489,7 +489,7 @@ int __pmac media_bay_set_ide_infos(struct device_node* which_bay, unsigned long
         return -ENODEV;
 }
 
-static void __pmac media_bay_step(int i)
+static void media_bay_step(int i)
 {
         struct media_bay_info* bay = &media_bays[i];
 
@@ -619,7 +619,7 @@ static void __pmac media_bay_step(int i)
  * with the IDE driver.  It needs to be a thread because
  * ide_register can't be called from interrupt context.
  */
-static int __pmac media_bay_task(void *x)
+static int media_bay_task(void *x)
 {
         int     i;
 
@@ -704,7 +704,7 @@ static int __devinit media_bay_attach(struct macio_dev *mdev, const struct of_de
 
 }
 
-static int __pmac media_bay_suspend(struct macio_dev *mdev, pm_message_t state)
+static int media_bay_suspend(struct macio_dev *mdev, pm_message_t state)
 {
         struct media_bay_info   *bay = macio_get_drvdata(mdev);
 
@@ -719,7 +719,7 @@ static int __pmac media_bay_suspend(struct macio_dev *mdev, pm_message_t state)
         return 0;
 }
 
-static int __pmac media_bay_resume(struct macio_dev *mdev)
+static int media_bay_resume(struct macio_dev *mdev)
 {
         struct media_bay_info   *bay = macio_get_drvdata(mdev);
 
@@ -760,7 +760,7 @@ static int __pmac media_bay_resume(struct macio_dev *mdev)
 
 /* Definitions of "ops" structures.
  */
-static struct mb_ops ohare_mb_ops __pmacdata = {
+static struct mb_ops ohare_mb_ops = {
         .name           = "Ohare",
         .content        = ohare_mb_content,
         .power          = ohare_mb_power,
@@ -769,7 +769,7 @@ static struct mb_ops ohare_mb_ops __pmacdata = {
         .un_reset_ide   = ohare_mb_un_reset_ide,
 };
 
-static struct mb_ops heathrow_mb_ops __pmacdata = {
+static struct mb_ops heathrow_mb_ops = {
         .name           = "Heathrow",
         .content        = heathrow_mb_content,
         .power          = heathrow_mb_power,
@@ -778,7 +778,7 @@ static struct mb_ops heathrow_mb_ops __pmacdata = {
         .un_reset_ide   = heathrow_mb_un_reset_ide,
 };
 
-static struct mb_ops keylargo_mb_ops __pmacdata = {
+static struct mb_ops keylargo_mb_ops = {
         .name           = "KeyLargo",
         .init           = keylargo_mb_init,
         .content        = keylargo_mb_content,
diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index 9b38674fbf75..34f3c7e2d832 100644
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -1094,7 +1094,7 @@ static int smu_release(struct inode *inode, struct file *file)
 }
 
 
-static struct file_operations smu_device_fops __pmacdata = {
+static struct file_operations smu_device_fops = {
         .llseek         = no_llseek,
         .read           = smu_read,
         .write          = smu_write,
@@ -1103,7 +1103,7 @@ static struct file_operations smu_device_fops __pmacdata = {
         .release        = smu_release,
 };
 
-static struct miscdevice pmu_device __pmacdata = {
+static struct miscdevice pmu_device = {
         MISC_DYNAMIC_MINOR, "smu", &smu_device_fops
 };
 
diff --git a/drivers/macintosh/via-cuda.c b/drivers/macintosh/via-cuda.c
index 417deb5de108..d843a6c9c6df 100644
--- a/drivers/macintosh/via-cuda.c
+++ b/drivers/macintosh/via-cuda.c
@@ -37,7 +37,6 @@ static DEFINE_SPINLOCK(cuda_lock);
 
 #ifdef CONFIG_MAC
 #define CUDA_IRQ IRQ_MAC_ADB
-#define __openfirmware
 #define eieio()
 #else
 #define CUDA_IRQ vias->intrs[0].line
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index 645a2e5c70ab..91920a1140fa 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -244,7 +244,7 @@ int pmu_wink(struct adb_request *req);
  * - the number of response bytes which the PMU will return, or
  *   -1 if it will send a length byte.
  */
-static const s8 pmu_data_len[256][2] __openfirmwaredata = {
+static const s8 pmu_data_len[256][2] = {
 /*         0       1       2       3       4       5       6       7  */
 /*00*/  {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
 /*08*/  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
@@ -295,7 +295,7 @@ static struct backlight_controller pmu_backlight_controller = {
 };
 #endif /* CONFIG_PMAC_BACKLIGHT */
 
-int __openfirmware
+int
 find_via_pmu(void)
 {
         if (via != 0)
@@ -374,7 +374,7 @@ find_via_pmu(void)
 }
 
 #ifdef CONFIG_ADB
-static int __openfirmware
+static int
 pmu_probe(void)
 {
         return vias == NULL? -ENODEV: 0;
@@ -405,7 +405,7 @@ static int __init via_pmu_start(void)
         bright_req_2.complete = 1;
         batt_req.complete = 1;
 
-#ifdef CONFIG_PPC32
+#if defined(CONFIG_PPC32) && !defined(CONFIG_PPC_MERGE)
         if (pmu_kind == PMU_KEYLARGO_BASED)
                 openpic_set_irq_priority(vias->intrs[0].line,
                                          OPENPIC_PRIORITY_DEFAULT + 1);
@@ -520,7 +520,7 @@ static int __init via_pmu_dev_init(void)
 
 device_initcall(via_pmu_dev_init);
 
-static int __openfirmware
+static int
 init_pmu(void)
 {
         int timeout;
@@ -588,17 +588,6 @@ pmu_get_model(void)
         return pmu_kind;
 }
 
-#ifndef CONFIG_PPC64
-static inline void wakeup_decrementer(void)
-{
-        set_dec(tb_ticks_per_jiffy);
-        /* No currently-supported powerbook has a 601,
-         * so use get_tbl, not native
-         */
-        last_jiffy_stamp(0) = tb_last_stamp = get_tbl();
-}
-#endif
-
 static void pmu_set_server_mode(int server_mode)
 {
         struct adb_request req;
@@ -625,7 +614,7 @@ static void pmu_set_server_mode(int server_mode)
 /* This new version of the code for 2400/3400/3500 powerbooks
  * is inspired from the implementation in gkrellm-pmu
  */
-static void __pmac
+static void
 done_battery_state_ohare(struct adb_request* req)
 {
         /* format:
@@ -713,7 +702,7 @@ done_battery_state_ohare(struct adb_request* req)
         clear_bit(0, &async_req_locks);
 }
 
-static void __pmac
+static void
 done_battery_state_smart(struct adb_request* req)
 {
         /* format:
@@ -791,7 +780,7 @@ done_battery_state_smart(struct adb_request* req)
         clear_bit(0, &async_req_locks);
 }
 
-static void __pmac
+static void
 query_battery_state(void)
 {
         if (test_and_set_bit(0, &async_req_locks))
@@ -804,7 +793,7 @@ query_battery_state(void)
                         2, PMU_SMART_BATTERY_STATE, pmu_cur_battery+1);
 }
 
-static int __pmac
+static int
 proc_get_info(char *page, char **start, off_t off,
                 int count, int *eof, void *data)
 {
@@ -819,7 +808,7 @@ proc_get_info(char *page, char **start, off_t off,
         return p - page;
 }
 
-static int __pmac
+static int
 proc_get_irqstats(char *page, char **start, off_t off,
                   int count, int *eof, void *data)
 {
@@ -846,7 +835,7 @@ proc_get_irqstats(char *page, char **start, off_t off,
         return p - page;
 }
 
-static int __pmac
+static int
 proc_get_batt(char *page, char **start, off_t off,
                 int count, int *eof, void *data)
 {
@@ -870,7 +859,7 @@ proc_get_batt(char *page, char **start, off_t off,
         return p - page;
 }
 
-static int __pmac
+static int
 proc_read_options(char *page, char **start, off_t off,
                         int count, int *eof, void *data)
 {
@@ -887,7 +876,7 @@ proc_read_options(char *page, char **start, off_t off,
         return p - page;
 }
                         
-static int __pmac
+static int
 proc_write_options(struct file *file, const char __user *buffer,
                         unsigned long count, void *data)
 {
@@ -934,7 +923,7 @@ proc_write_options(struct file *file, const char __user *buffer,
 
 #ifdef CONFIG_ADB
 /* Send an ADB command */
-static int __pmac
+static int
 pmu_send_request(struct adb_request *req, int sync)
 {
         int i, ret;
@@ -1014,7 +1003,7 @@ pmu_send_request(struct adb_request *req, int sync)
 }
 
 /* Enable/disable autopolling */
-static int __pmac
+static int
 pmu_adb_autopoll(int devs)
 {
         struct adb_request req;
@@ -1037,7 +1026,7 @@ pmu_adb_autopoll(int devs)
 }
 
 /* Reset the ADB bus */
-static int __pmac
+static int
 pmu_adb_reset_bus(void)
 {
         struct adb_request req;
@@ -1072,7 +1061,7 @@ pmu_adb_reset_bus(void)
 #endif /* CONFIG_ADB */
 
 /* Construct and send a pmu request */
-int __openfirmware
+int
 pmu_request(struct adb_request *req, void (*done)(struct adb_request *),
             int nbytes, ...)
 {
@@ -1098,7 +1087,7 @@ pmu_request(struct adb_request *req, void (*done)(struct adb_request *),
         return pmu_queue_request(req);
 }
 
-int __pmac
+int
 pmu_queue_request(struct adb_request *req)
 {
         unsigned long flags;
@@ -1190,7 +1179,7 @@ pmu_done(struct adb_request *req)
                 (*done)(req);
 }
 
-static void __pmac
+static void
 pmu_start(void)
 {
         struct adb_request *req;
@@ -1214,7 +1203,7 @@ pmu_start(void)
         send_byte(req->data[0]);
 }
 
-void __openfirmware
+void
 pmu_poll(void)
 {
         if (!via)
@@ -1224,7 +1213,7 @@ pmu_poll(void)
         via_pmu_interrupt(0, NULL, NULL);
 }
 
-void __openfirmware
+void
 pmu_poll_adb(void)
 {
         if (!via)
@@ -1239,7 +1228,7 @@ pmu_poll_adb(void)
                 || req_awaiting_reply));
 }
 
-void __openfirmware
+void
 pmu_wait_complete(struct adb_request *req)
 {
         if (!via)
@@ -1253,7 +1242,7 @@ pmu_wait_complete(struct adb_request *req)
  * This is done to avoid spurrious shutdowns when we know we'll have
  * interrupts switched off for a long time
  */
-void __openfirmware
+void
 pmu_suspend(void)
 {
         unsigned long flags;
@@ -1293,7 +1282,7 @@ pmu_suspend(void)
         } while (1);
 }
 
-void __openfirmware
+void
 pmu_resume(void)
 {
         unsigned long flags;
@@ -1323,7 +1312,7 @@ pmu_resume(void)
 }
 
 /* Interrupt data could be the result data from an ADB cmd */
-static void __pmac
+static void
 pmu_handle_data(unsigned char *data, int len, struct pt_regs *regs)
 {
         unsigned char ints, pirq;
@@ -1435,7 +1424,7 @@ next:
         goto next;
 }
 
-static struct adb_request* __pmac
+static struct adb_request*
 pmu_sr_intr(struct pt_regs *regs)
 {
         struct adb_request *req;
@@ -1541,7 +1530,7 @@ pmu_sr_intr(struct pt_regs *regs)
         return NULL;
 }
 
-static irqreturn_t __pmac
+static irqreturn_t
 via_pmu_interrupt(int irq, void *arg, struct pt_regs *regs)
 {
         unsigned long flags;
@@ -1629,7 +1618,7 @@ no_free_slot:
         return IRQ_RETVAL(handled);
 }
 
-void __pmac
+void
 pmu_unlock(void)
 {
         unsigned long flags;
@@ -1642,7 +1631,7 @@ pmu_unlock(void)
 }
 
 
-static irqreturn_t __pmac
+static irqreturn_t
 gpio1_interrupt(int irq, void *arg, struct pt_regs *regs)
 {
         unsigned long flags;
@@ -1663,12 +1652,12 @@ gpio1_interrupt(int irq, void *arg, struct pt_regs *regs)
 }
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-static int backlight_to_bright[] __pmacdata = {
+static int backlight_to_bright[] = {
         0x7f, 0x46, 0x42, 0x3e, 0x3a, 0x36, 0x32, 0x2e,
         0x2a, 0x26, 0x22, 0x1e, 0x1a, 0x16, 0x12, 0x0e
 };
  
-static int __openfirmware
+static int
 pmu_set_backlight_enable(int on, int level, void* data)
 {
         struct adb_request req;
@@ -1688,7 +1677,7 @@ pmu_set_backlight_enable(int on, int level, void* data)
         return 0;
 }
 
-static void __openfirmware
+static void
 pmu_bright_complete(struct adb_request *req)
 {
         if (req == &bright_req_1)
@@ -1697,7 +1686,7 @@ pmu_bright_complete(struct adb_request *req)
                 clear_bit(2, &async_req_locks);
 }
 
-static int __openfirmware
+static int
 pmu_set_backlight_level(int level, void* data)
 {
         if (vias == NULL)
@@ -1717,7 +1706,7 @@ pmu_set_backlight_level(int level, void* data)
 }
 #endif /* CONFIG_PMAC_BACKLIGHT */
 
-void __pmac
+void
 pmu_enable_irled(int on)
 {
         struct adb_request req;
@@ -1732,7 +1721,7 @@ pmu_enable_irled(int on)
         pmu_wait_complete(&req);
 }
 
-void __pmac
+void
 pmu_restart(void)
 {
         struct adb_request req;
@@ -1757,7 +1746,7 @@ pmu_restart(void)
                 ;
 }
 
-void __pmac
+void
 pmu_shutdown(void)
 {
         struct adb_request req;
@@ -2076,7 +2065,7 @@ pmu_unregister_sleep_notifier(struct pmu_sleep_notifier* n)
 }
 
 /* Sleep is broadcast last-to-first */
-static int __pmac
+static int
 broadcast_sleep(int when, int fallback)
 {
         int ret = PBOOK_SLEEP_OK;
@@ -2101,7 +2090,7 @@ broadcast_sleep(int when, int fallback)
 }
 
 /* Wake is broadcast first-to-last */
-static int __pmac
+static int
 broadcast_wake(void)
 {
         int ret = PBOOK_SLEEP_OK;
@@ -2132,7 +2121,7 @@ static struct pci_save {
 } *pbook_pci_saves;
 static int pbook_npci_saves;
 
-static void __pmac
+static void
 pbook_alloc_pci_save(void)
 {
         int npci;
@@ -2149,7 +2138,7 @@ pbook_alloc_pci_save(void)
         pbook_npci_saves = npci;
 }
 
-static void __pmac
+static void
 pbook_free_pci_save(void)
 {
         if (pbook_pci_saves == NULL)
@@ -2159,7 +2148,7 @@ pbook_free_pci_save(void)
         pbook_npci_saves = 0;
 }
 
-static void __pmac
+static void
 pbook_pci_save(void)
 {
         struct pci_save *ps = pbook_pci_saves;
@@ -2190,7 +2179,7 @@ pbook_pci_save(void)
  * during boot, it will be in the pci dev list. If it's disabled at this point
  * (and it will probably be), then you can't access it's config space.
  */
-static void __pmac
+static void
 pbook_pci_restore(void)
 {
         u16 cmd;
@@ -2238,7 +2227,7 @@ pbook_pci_restore(void)
 
 #ifdef DEBUG_SLEEP
 /* N.B. This doesn't work on the 3400 */
-void  __pmac
+void 
 pmu_blink(int n)
 {
         struct adb_request req;
@@ -2277,9 +2266,9 @@ pmu_blink(int n)
  * Put the powerbook to sleep.
  */
  
-static u32 save_via[8] __pmacdata;
+static u32 save_via[8];
 
-static void __pmac
+static void
 save_via_state(void)
 {
         save_via[0] = in_8(&via[ANH]);
@@ -2291,7 +2280,7 @@ save_via_state(void)
         save_via[6] = in_8(&via[T1CL]);
         save_via[7] = in_8(&via[T1CH]);
 }
-static void __pmac
+static void
 restore_via_state(void)
 {
         out_8(&via[ANH], save_via[0]);
@@ -2307,7 +2296,7 @@ restore_via_state(void)
         out_8(&via[IER], IER_SET | SR_INT | CB1_INT);
 }
 
-static int __pmac
+static int
 pmac_suspend_devices(void)
 {
         int ret;
@@ -2397,7 +2386,7 @@ pmac_suspend_devices(void)
         return 0;
 }
 
-static int __pmac
+static int
 pmac_wakeup_devices(void)
 {
         mdelay(100);
@@ -2436,7 +2425,7 @@ pmac_wakeup_devices(void)
 #define GRACKLE_NAP     (1<<4)
 #define GRACKLE_SLEEP   (1<<3)
 
-int __pmac
+int
 powerbook_sleep_grackle(void)
 {
         unsigned long save_l2cr;
@@ -2520,7 +2509,7 @@ powerbook_sleep_grackle(void)
         return 0;
 }
 
-static int __pmac
+static int
 powerbook_sleep_Core99(void)
 {
         unsigned long save_l2cr;
@@ -2620,7 +2609,7 @@ powerbook_sleep_Core99(void)
 #define PB3400_MEM_CTRL         0xf8000000
 #define PB3400_MEM_CTRL_SLEEP   0x70
 
-static int __pmac
+static int
 powerbook_sleep_3400(void)
 {
         int ret, i, x;
@@ -2720,9 +2709,9 @@ struct pmu_private {
 };
 
 static LIST_HEAD(all_pmu_pvt);
-static DEFINE_SPINLOCK(all_pvt_lock __pmacdata);
+static DEFINE_SPINLOCK(all_pvt_lock);
 
-static void __pmac
+static void
 pmu_pass_intr(unsigned char *data, int len)
 {
         struct pmu_private *pp;
@@ -2751,7 +2740,7 @@ pmu_pass_intr(unsigned char *data, int len)
         spin_unlock_irqrestore(&all_pvt_lock, flags);
 }
 
-static int __pmac
+static int
 pmu_open(struct inode *inode, struct file *file)
 {
         struct pmu_private *pp;
@@ -2773,7 +2762,7 @@ pmu_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t  __pmac
+static ssize_t 
 pmu_read(struct file *file, char __user *buf,
                         size_t count, loff_t *ppos)
 {
@@ -2825,14 +2814,14 @@ pmu_read(struct file *file, char __user *buf,
         return ret;
 }
 
-static ssize_t __pmac
+static ssize_t
 pmu_write(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos)
 {
         return 0;
 }
 
-static unsigned int __pmac
+static unsigned int
 pmu_fpoll(struct file *filp, poll_table *wait)
 {
         struct pmu_private *pp = filp->private_data;
@@ -2849,7 +2838,7 @@ pmu_fpoll(struct file *filp, poll_table *wait)
         return mask;
 }
 
-static int __pmac
+static int
 pmu_release(struct inode *inode, struct file *file)
 {
         struct pmu_private *pp = file->private_data;
@@ -2874,8 +2863,7 @@ pmu_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-/* Note: removed __openfirmware here since it causes link errors */
-static int __pmac
+static int
 pmu_ioctl(struct inode * inode, struct file *filp,
                      u_int cmd, u_long arg)
 {
@@ -2957,7 +2945,7 @@ pmu_ioctl(struct inode * inode, struct file *filp,
         return error;
 }
 
-static struct file_operations pmu_device_fops __pmacdata = {
+static struct file_operations pmu_device_fops = {
         .read           = pmu_read,
         .write          = pmu_write,
         .poll           = pmu_fpoll,
@@ -2966,7 +2954,7 @@ static struct file_operations pmu_device_fops __pmacdata = {
         .release        = pmu_release,
 };
 
-static struct miscdevice pmu_device __pmacdata = {
+static struct miscdevice pmu_device = {
         PMU_MINOR, "pmu", &pmu_device_fops
 };
 
@@ -2982,7 +2970,7 @@ device_initcall(pmu_device_init);
 
 
 #ifdef DEBUG_SLEEP
-static inline void  __pmac
+static inline void 
 polled_handshake(volatile unsigned char __iomem *via)
 {
         via[B] &= ~TREQ; eieio();
@@ -2993,7 +2981,7 @@ polled_handshake(volatile unsigned char __iomem *via)
                 ;
 }
 
-static inline void  __pmac
+static inline void 
 polled_send_byte(volatile unsigned char __iomem *via, int x)
 {
         via[ACR] |= SR_OUT | SR_EXT; eieio();
@@ -3001,7 +2989,7 @@ polled_send_byte(volatile unsigned char __iomem *via, int x)
         polled_handshake(via);
 }
 
-static inline int __pmac
+static inline int
 polled_recv_byte(volatile unsigned char __iomem *via)
 {
         int x;
@@ -3013,7 +3001,7 @@ polled_recv_byte(volatile unsigned char __iomem *via)
         return x;
 }
 
-int __pmac
+int
 pmu_polled_request(struct adb_request *req)
 {
         unsigned long flags;
diff --git a/drivers/macintosh/via-pmu68k.c b/drivers/macintosh/via-pmu68k.c
index 820dc52e30bc..6f80d76ac17c 100644
--- a/drivers/macintosh/via-pmu68k.c
+++ b/drivers/macintosh/via-pmu68k.c
@@ -835,7 +835,7 @@ static struct pci_save {
 } *pbook_pci_saves;
 static int n_pbook_pci_saves;
 
-static inline void __openfirmware
+static inline void
 pbook_pci_save(void)
 {
         int npci;
@@ -863,7 +863,7 @@ pbook_pci_save(void)
         }
 }
 
-static inline void __openfirmware
+static inline void
 pbook_pci_restore(void)
 {
         u16 cmd;
@@ -902,7 +902,7 @@ pbook_pci_restore(void)
 #define IRQ_ENABLE      ((unsigned int *)0xf3000024)
 #define MEM_CTRL        ((unsigned int *)0xf8000070)
 
-int __openfirmware powerbook_sleep(void)
+int powerbook_sleep(void)
 {
         int ret, i, x;
         static int save_backlight;
@@ -1001,25 +1001,24 @@ int __openfirmware powerbook_sleep(void)
 /*
  * Support for /dev/pmu device
  */
-static int __openfirmware pmu_open(struct inode *inode, struct file *file)
+static int pmu_open(struct inode *inode, struct file *file)
 {
         return 0;
 }
 
-static ssize_t __openfirmware pmu_read(struct file *file, char *buf,
+static ssize_t pmu_read(struct file *file, char *buf,
                         size_t count, loff_t *ppos)
 {
         return 0;
 }
 
-static ssize_t __openfirmware pmu_write(struct file *file, const char *buf,
+static ssize_t pmu_write(struct file *file, const char *buf,
                          size_t count, loff_t *ppos)
 {
         return 0;
 }
 
-/* Note: removed __openfirmware here since it causes link errors */
-static int /*__openfirmware*/ pmu_ioctl(struct inode * inode, struct file *filp,
+static int pmu_ioctl(struct inode * inode, struct file *filp,
                      u_int cmd, u_long arg)
 {
         int error;
diff --git a/drivers/mca/mca-device.c b/drivers/mca/mca-device.c
index 76d430aa243f..e7adf89fae41 100644
--- a/drivers/mca/mca-device.c
+++ b/drivers/mca/mca-device.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/mca.h>
+#include <linux/string.h>
 
 /**
  *      mca_device_read_stored_pos - read POS register from stored data
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 28c1a628621f..cf6631056683 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -15,7 +15,7 @@
 #include <linux/crypto.h>
 #include <linux/workqueue.h>
 #include <asm/atomic.h>
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 #include <asm/page.h>
 
 #include "dm.h"
@@ -164,9 +164,7 @@ static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
                 return -ENOMEM;
         }
 
-        sg.page = virt_to_page(cc->key);
-        sg.offset = offset_in_page(cc->key);
-        sg.length = cc->key_size;
+        sg_set_buf(&sg, cc->key, cc->key_size);
         crypto_digest_digest(hash_tfm, &sg, 1, salt);
         crypto_free_tfm(hash_tfm);
 
@@ -207,14 +205,12 @@ static void crypt_iv_essiv_dtr(struct crypt_config *cc)
 
 static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
 {
-        struct scatterlist sg = { NULL, };
+        struct scatterlist sg;
 
         memset(iv, 0, cc->iv_size);
         *(u64 *)iv = cpu_to_le64(sector);
 
-        sg.page = virt_to_page(iv);
-        sg.offset = offset_in_page(iv);
-        sg.length = cc->iv_size;
+        sg_set_buf(&sg, iv, cc->iv_size);
         crypto_cipher_encrypt((struct crypto_tfm *)cc->iv_gen_private,
                               &sg, &sg, cc->iv_size);
 
diff --git a/drivers/media/common/ir-common.c b/drivers/media/common/ir-common.c
index 06f4d4686a6c..31fccb4f05d6 100644
--- a/drivers/media/common/ir-common.c
+++ b/drivers/media/common/ir-common.c
@@ -22,6 +22,7 @@
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/string.h>
 #include <media/ir-common.h>
 
 /* -------------------------------------------------------------------------- */
diff --git a/drivers/media/dvb/dvb-core/dvb_ca_en50221.c b/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
index 88757e2634e5..2aa767f9bd7d 100644
--- a/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
+++ b/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
@@ -36,6 +36,7 @@
 #include <linux/vmalloc.h>
 #include <linux/delay.h>
 #include <linux/rwsem.h>
+#include <linux/sched.h>
 
 #include "dvb_ca_en50221.h"
 #include "dvb_ringbuffer.h"
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.c b/drivers/media/dvb/dvb-usb/dtt200u.c
index 5aa12ebab34f..b595476332cd 100644
--- a/drivers/media/dvb/dvb-usb/dtt200u.c
+++ b/drivers/media/dvb/dvb-usb/dtt200u.c
@@ -151,7 +151,7 @@ static struct dvb_usb_properties dtt200u_properties = {
                   .cold_ids = { &dtt200u_usb_table[0], NULL },
                   .warm_ids = { &dtt200u_usb_table[1], NULL },
                 },
-                { 0 },
+                { NULL },
         }
 };
 
@@ -192,7 +192,7 @@ static struct dvb_usb_properties wt220u_properties = {
                   .cold_ids = { &dtt200u_usb_table[2], NULL },
                   .warm_ids = { &dtt200u_usb_table[3], NULL },
                 },
-                { 0 },
+                { NULL },
         }
 };
 
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c
index 0f57abeb6d6b..75765e3a569c 100644
--- a/drivers/media/dvb/dvb-usb/vp7045.c
+++ b/drivers/media/dvb/dvb-usb/vp7045.c
@@ -247,7 +247,7 @@ static struct dvb_usb_properties vp7045_properties = {
                   .cold_ids = { &vp7045_usb_table[2], NULL },
                   .warm_ids = { &vp7045_usb_table[3], NULL },
                 },
-                { 0 },
+                { NULL },
         }
 };
 
diff --git a/drivers/media/dvb/frontends/bcm3510.c b/drivers/media/dvb/frontends/bcm3510.c
index f5fdc5c3e605..f6d4ee78bdd4 100644
--- a/drivers/media/dvb/frontends/bcm3510.c
+++ b/drivers/media/dvb/frontends/bcm3510.c
@@ -36,6 +36,9 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/jiffies.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "bcm3510.h"
diff --git a/drivers/media/dvb/frontends/dib3000mb.c b/drivers/media/dvb/frontends/dib3000mb.c
index 21433e1831e7..6b0553608610 100644
--- a/drivers/media/dvb/frontends/dib3000mb.c
+++ b/drivers/media/dvb/frontends/dib3000mb.c
@@ -27,6 +27,8 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dib3000-common.h"
 #include "dib3000mb_priv.h"
diff --git a/drivers/media/dvb/frontends/dib3000mc.c b/drivers/media/dvb/frontends/dib3000mc.c
index 441de665fec3..c024fad17337 100644
--- a/drivers/media/dvb/frontends/dib3000mc.c
+++ b/drivers/media/dvb/frontends/dib3000mc.c
@@ -26,6 +26,8 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dib3000-common.h"
 #include "dib3000mc_priv.h"
diff --git a/drivers/media/dvb/frontends/dvb_dummy_fe.c b/drivers/media/dvb/frontends/dvb_dummy_fe.c
index cff93b9d8ab2..794be520d590 100644
--- a/drivers/media/dvb/frontends/dvb_dummy_fe.c
+++ b/drivers/media/dvb/frontends/dvb_dummy_fe.c
@@ -22,6 +22,8 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "dvb_dummy_fe.h"
diff --git a/drivers/media/dvb/frontends/lgdt330x.c b/drivers/media/dvb/frontends/lgdt330x.c
index 7142b9c51dd2..8dde72bd1046 100644
--- a/drivers/media/dvb/frontends/lgdt330x.c
+++ b/drivers/media/dvb/frontends/lgdt330x.c
@@ -37,6 +37,8 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <asm/byteorder.h>
 
 #include "dvb_frontend.h"
diff --git a/drivers/media/dvb/frontends/mt312.c b/drivers/media/dvb/frontends/mt312.c
index e455aecd76b2..e38454901dd1 100644
--- a/drivers/media/dvb/frontends/mt312.c
+++ b/drivers/media/dvb/frontends/mt312.c
@@ -29,6 +29,8 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "mt312_priv.h"
diff --git a/drivers/media/dvb/frontends/mt352.c b/drivers/media/dvb/frontends/mt352.c
index cc1bc0edd65e..f0c610f2c2df 100644
--- a/drivers/media/dvb/frontends/mt352.c
+++ b/drivers/media/dvb/frontends/mt352.c
@@ -35,6 +35,8 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "mt352_priv.h"
diff --git a/drivers/media/dvb/frontends/nxt2002.c b/drivers/media/dvb/frontends/nxt2002.c
index 35a1d60f1927..30786b1911bd 100644
--- a/drivers/media/dvb/frontends/nxt2002.c
+++ b/drivers/media/dvb/frontends/nxt2002.c
@@ -32,6 +32,8 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "nxt2002.h"
diff --git a/drivers/media/dvb/frontends/or51132.c b/drivers/media/dvb/frontends/or51132.c
index b6d0eecc59eb..817b044c7fd1 100644
--- a/drivers/media/dvb/frontends/or51132.c
+++ b/drivers/media/dvb/frontends/or51132.c
@@ -36,6 +36,8 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <asm/byteorder.h>
 
 #include "dvb_frontend.h"
diff --git a/drivers/media/dvb/frontends/or51211.c b/drivers/media/dvb/frontends/or51211.c
index ad56a9958404..8a9db23dd1b7 100644
--- a/drivers/media/dvb/frontends/or51211.c
+++ b/drivers/media/dvb/frontends/or51211.c
@@ -34,6 +34,8 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <asm/byteorder.h>
 
 #include "dvb_frontend.h"
diff --git a/drivers/media/dvb/frontends/s5h1420.c b/drivers/media/dvb/frontends/s5h1420.c
index c7fe27fd530c..f265418e3261 100644
--- a/drivers/media/dvb/frontends/s5h1420.c
+++ b/drivers/media/dvb/frontends/s5h1420.c
@@ -26,6 +26,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <asm/div64.h>
 
 #include "dvb_frontend.h"
 #include "s5h1420.h"
diff --git a/drivers/media/dvb/frontends/sp8870.c b/drivers/media/dvb/frontends/sp8870.c
index 764a95a2e212..1c6b2e9264bc 100644
--- a/drivers/media/dvb/frontends/sp8870.c
+++ b/drivers/media/dvb/frontends/sp8870.c
@@ -32,6 +32,8 @@
 #include <linux/device.h>
 #include <linux/firmware.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "sp8870.h"
diff --git a/drivers/media/dvb/frontends/sp887x.c b/drivers/media/dvb/frontends/sp887x.c
index d868a6927a16..73384e75625e 100644
--- a/drivers/media/dvb/frontends/sp887x.c
+++ b/drivers/media/dvb/frontends/sp887x.c
@@ -14,6 +14,8 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "sp887x.h"
diff --git a/drivers/media/dvb/frontends/stv0297.c b/drivers/media/dvb/frontends/stv0297.c
index 8d09afd7545d..6122ba754bc5 100644
--- a/drivers/media/dvb/frontends/stv0297.c
+++ b/drivers/media/dvb/frontends/stv0297.c
@@ -24,6 +24,8 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/slab.h>
 
 #include "dvb_frontend.h"
 #include "stv0297.h"
diff --git a/drivers/media/dvb/frontends/stv0299.c b/drivers/media/dvb/frontends/stv0299.c
index 2d62931f20b5..889d9257215d 100644
--- a/drivers/media/dvb/frontends/stv0299.c
+++ b/drivers/media/dvb/frontends/stv0299.c
@@ -48,6 +48,7 @@
 #include <linux/moduleparam.h>
 #include <linux/string.h>
 #include <linux/slab.h>
+#include <linux/jiffies.h>
 #include <asm/div64.h>
 
 #include "dvb_frontend.h"
diff --git a/drivers/media/dvb/frontends/tda1004x.c b/drivers/media/dvb/frontends/tda1004x.c
index 74cea9f8d721..3529c618f828 100644
--- a/drivers/media/dvb/frontends/tda1004x.c
+++ b/drivers/media/dvb/frontends/tda1004x.c
@@ -32,6 +32,10 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/device.h>
+#include <linux/jiffies.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
 #include "dvb_frontend.h"
 #include "tda1004x.h"
 
diff --git a/drivers/media/dvb/frontends/tda8083.c b/drivers/media/dvb/frontends/tda8083.c
index 168e013d23bd..c05cf1861051 100644
--- a/drivers/media/dvb/frontends/tda8083.c
+++ b/drivers/media/dvb/frontends/tda8083.c
@@ -30,6 +30,7 @@
 #include <linux/moduleparam.h>
 #include <linux/string.h>
 #include <linux/slab.h>
+#include <linux/jiffies.h>
 #include "dvb_frontend.h"
 #include "tda8083.h"
 
diff --git a/drivers/media/radio/miropcm20-rds.c b/drivers/media/radio/miropcm20-rds.c
index df79d5e0aaed..e09214082e01 100644
--- a/drivers/media/radio/miropcm20-rds.c
+++ b/drivers/media/radio/miropcm20-rds.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
+#include <linux/sched.h>        /* current, TASK_*, schedule_timeout() */
 #include <linux/delay.h>
 #include <asm/uaccess.h>
 #include "miropcm20-rds-core.h"
diff --git a/drivers/media/video/indycam.c b/drivers/media/video/indycam.c
index b2b0384cd4b9..26dd06ec89a2 100644
--- a/drivers/media/video/indycam.c
+++ b/drivers/media/video/indycam.c
@@ -9,16 +9,16 @@
  *  published by the Free Software Foundation.
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/major.h>
-#include <linux/slab.h>
+#include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 
 #include <linux/videodev.h>
 /* IndyCam decodes stream of photons into digital image representation ;-) */
@@ -44,8 +44,6 @@ MODULE_LICENSE("GPL");
 #define indycam_regdump(client)
 #endif
 
-#define VINO_ADAPTER    (I2C_ALGO_SGI | I2C_HW_SGI_VINO)
-
 struct indycam {
         struct i2c_client *client;
         int version;
@@ -300,7 +298,7 @@ out_free_client:
 static int indycam_probe(struct i2c_adapter *adap)
 {
         /* Indy specific crap */
-        if (adap->id == VINO_ADAPTER)
+        if (adap->id == I2C_HW_SGI_VINO)
                 return indycam_attach(adap, INDYCAM_ADDR, 0);
         /* Feel free to add probe here :-) */
         return -ENODEV;
diff --git a/drivers/media/video/saa7191.c b/drivers/media/video/saa7191.c
index 454f5c1199b4..3ddbb62312be 100644
--- a/drivers/media/video/saa7191.c
+++ b/drivers/media/video/saa7191.c
@@ -9,16 +9,16 @@
  *  published by the Free Software Foundation.
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/major.h>
-#include <linux/slab.h>
+#include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 
 #include <linux/videodev.h>
 #include <linux/video_decoder.h>
@@ -33,8 +33,6 @@ MODULE_VERSION(SAA7191_MODULE_VERSION);
 MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
 MODULE_LICENSE("GPL");
 
-#define VINO_ADAPTER    (I2C_ALGO_SGI | I2C_HW_SGI_VINO)
-
 struct saa7191 {
         struct i2c_client *client;
 
@@ -337,7 +335,7 @@ out_free_client:
 static int saa7191_probe(struct i2c_adapter *adap)
 {
         /* Always connected to VINO */
-        if (adap->id == VINO_ADAPTER)
+        if (adap->id == I2C_HW_SGI_VINO)
                 return saa7191_attach(adap, SAA7191_ADDR, 0);
         /* Feel free to add probe here :-) */
         return -ENODEV;
@@ -364,7 +362,7 @@ static int saa7191_command(struct i2c_client *client, unsigned int cmd,
 
                 cap->flags  = VIDEO_DECODER_PAL | VIDEO_DECODER_NTSC |
                               VIDEO_DECODER_SECAM | VIDEO_DECODER_AUTO;
-                cap->inputs = (client->adapter->id == VINO_ADAPTER) ? 2 : 1;
+                cap->inputs = (client->adapter->id == I2C_HW_SGI_VINO) ? 2 : 1;
                 cap->outputs = 1;
                 break;
         }
@@ -422,7 +420,7 @@ static int saa7191_command(struct i2c_client *client, unsigned int cmd,
                 int *iarg = arg;
 
                 switch (client->adapter->id) {
-                case VINO_ADAPTER:
+                case I2C_HW_SGI_VINO:
                         return saa7191_set_input(client, *iarg);
                 default:
                         if (*iarg != 0)
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index d8a0f763ca10..ed4394e854ab 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -26,14 +26,15 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/delay.h>
+#include <linux/dma-mapping.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
-#include <linux/interrupt.h>
-#include <linux/dma-mapping.h>
-#include <linux/time.h>
 #include <linux/moduleparam.h>
+#include <linux/time.h>
+#include <linux/version.h>
 
 #ifdef CONFIG_KMOD
 #include <linux/kmod.h>
diff --git a/drivers/message/i2o/debug.c b/drivers/message/i2o/debug.c
index 018ca887ca85..40d4ea898dbc 100644
--- a/drivers/message/i2o/debug.c
+++ b/drivers/message/i2o/debug.c
@@ -90,7 +90,7 @@ static void i2o_report_fail_status(u8 req_status, u32 * msg)
         };
 
         if (req_status == I2O_FSC_TRANSPORT_UNKNOWN_FAILURE)
-                printk(KERN_DEBUG "TRANSPORT_UNKNOWN_FAILURE (%0#2x)\n.",
+                printk(KERN_DEBUG "TRANSPORT_UNKNOWN_FAILURE (%0#2x).\n",
                        req_status);
         else
                 printk(KERN_DEBUG "TRANSPORT_%s.\n",
diff --git a/drivers/message/i2o/device.c b/drivers/message/i2o/device.c
index d9879965eb50..8eb50cdb8ae1 100644
--- a/drivers/message/i2o/device.c
+++ b/drivers/message/i2o/device.c
@@ -16,6 +16,8 @@
 #include <linux/module.h>
 #include <linux/i2o.h>
 #include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include "core.h"
 
 /**
diff --git a/drivers/message/i2o/driver.c b/drivers/message/i2o/driver.c
index 0079a4be0af2..0fb9c4e2ad4c 100644
--- a/drivers/message/i2o/driver.c
+++ b/drivers/message/i2o/driver.c
@@ -17,6 +17,9 @@
 #include <linux/module.h>
 #include <linux/rwsem.h>
 #include <linux/i2o.h>
+#include <linux/workqueue.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include "core.h"
 
 #define OSM_NAME        "i2o"
diff --git a/drivers/message/i2o/exec-osm.c b/drivers/message/i2o/exec-osm.c
index bda2c62648ba..b675b4ebbebd 100644
--- a/drivers/message/i2o/exec-osm.c
+++ b/drivers/message/i2o/exec-osm.c
@@ -30,6 +30,10 @@
 #include <linux/module.h>
 #include <linux/i2o.h>
 #include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <asm/param.h>          /* HZ */
 #include "core.h"
 
 #define OSM_NAME "exec-osm"
diff --git a/drivers/message/i2o/iop.c b/drivers/message/i2o/iop.c
index 361da8d1d5e7..61b837de4b6a 100644
--- a/drivers/message/i2o/iop.c
+++ b/drivers/message/i2o/iop.c
@@ -28,6 +28,7 @@
 #include <linux/module.h>
 #include <linux/i2o.h>
 #include <linux/delay.h>
+#include <linux/sched.h>
 #include "core.h"
 
 #define OSM_NAME        "i2o"
diff --git a/drivers/mfd/ucb1x00-ts.c b/drivers/mfd/ucb1x00-ts.c
index 585cded3d365..a984c0efabf0 100644
--- a/drivers/mfd/ucb1x00-ts.c
+++ b/drivers/mfd/ucb1x00-ts.c
@@ -32,9 +32,12 @@
 #include <linux/suspend.h>
 #include <linux/slab.h>
 #include <linux/kthread.h>
+#include <linux/delay.h>
 
 #include <asm/dma.h>
 #include <asm/semaphore.h>
+#include <asm/arch/collie.h>
+#include <asm/mach-types.h>
 
 #include "ucb1x00.h"
 
@@ -85,12 +88,23 @@ static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts)
  */
 static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts)
 {
-        ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
-                        UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
-                        UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
-                        UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+        if (machine_is_collie()) {
+                ucb1x00_io_write(ts->ucb, COLLIE_TC35143_GPIO_TBL_CHK, 0);
+                ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
+                                  UCB_TS_CR_TSPX_POW | UCB_TS_CR_TSMX_POW |
+                                  UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
 
-        return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync);
+                udelay(55);
+
+                return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_AD2, ts->adcsync);
+        } else {
+                ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
+                                  UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
+                                  UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
+                                  UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+
+                return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync);
+        }
 }
 
 /*
@@ -101,12 +115,16 @@ static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts)
  */
 static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts)
 {
-        ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
-                        UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
-                        UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
-        ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
-                        UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
-                        UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+        if (machine_is_collie())
+                ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK);
+        else {
+                ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
+                                  UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
+                                  UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+                ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
+                                  UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
+                                  UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+        }
         ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
                         UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
                         UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
@@ -124,12 +142,17 @@ static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts)
  */
 static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts)
 {
-        ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
-                        UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
-                        UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
-        ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
-                        UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
-                        UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+        if (machine_is_collie())
+                ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK);
+        else {
+                ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
+                                  UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
+                                  UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+                ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
+                                  UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
+                                  UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
+        }
+
         ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
                         UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
                         UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
@@ -163,6 +186,15 @@ static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts)
         return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync);
 }
 
+static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts)
+{
+        unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR);
+        if (machine_is_collie())
+                return (!(val & (UCB_TS_CR_TSPX_LOW)));
+        else
+                return (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW));
+}
+
 /*
  * This is a RT kernel thread that handles the ADC accesses
  * (mainly so we can use semaphores in the UCB1200 core code
@@ -186,7 +218,7 @@ static int ucb1x00_thread(void *_ts)
 
         add_wait_queue(&ts->irq_wait, &wait);
         while (!kthread_should_stop()) {
-                unsigned int x, y, p, val;
+                unsigned int x, y, p;
                 signed long timeout;
 
                 ts->restart = 0;
@@ -206,12 +238,12 @@ static int ucb1x00_thread(void *_ts)
                 msleep(10);
 
                 ucb1x00_enable(ts->ucb);
-                val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR);
 
-                if (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW)) {
+
+                if (ucb1x00_ts_pen_down(ts)) {
                         set_task_state(tsk, TASK_INTERRUPTIBLE);
 
-                        ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING);
+                        ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, machine_is_collie() ? UCB_RISING : UCB_FALLING);
                         ucb1x00_disable(ts->ucb);
 
                         /*
diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index 4991bbd054f3..c483a863b116 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -60,4 +60,13 @@ config MMC_WBSD
 
           If unsure, say N.
 
+config MMC_AU1X
+        tristate "Alchemy AU1XX0 MMC Card Interface support"
+        depends on SOC_AU1X00 && MMC
+        help
+          This selects the AMD Alchemy(R) Multimedia card interface.
+          iIf you have a Alchemy platform with a MMC slot, say Y or M here.
+
+          If unsure, say N.
+
 endmenu
diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
index 89510c2086c7..e351e71146e9 100644
--- a/drivers/mmc/Makefile
+++ b/drivers/mmc/Makefile
@@ -18,5 +18,6 @@ obj-$(CONFIG_MMC_BLOCK)		+= mmc_block.o
 obj-$(CONFIG_MMC_ARMMMCI)       += mmci.o
 obj-$(CONFIG_MMC_PXA)           += pxamci.o
 obj-$(CONFIG_MMC_WBSD)          += wbsd.o
+obj-$(CONFIG_MMC_AU1X)          += au1xmmc.o
 
 mmc_core-y := mmc.o mmc_queue.o mmc_sysfs.o
diff --git a/drivers/mmc/au1xmmc.c b/drivers/mmc/au1xmmc.c
new file mode 100644
index 000000000000..aaf04638054e
--- /dev/null
+++ b/drivers/mmc/au1xmmc.c
@@ -0,0 +1,1026 @@
+/*
+ * linux/drivers/mmc/au1xmmc.c - AU1XX0 MMC driver
+ *
+ *  Copyright (c) 2005, Advanced Micro Devices, Inc.
+ *
+ *  Developed with help from the 2.4.30 MMC AU1XXX controller including
+ *  the following copyright notices:
+ *     Copyright (c) 2003-2004 Embedded Edge, LLC.
+ *     Portions Copyright (C) 2002 Embedix, Inc
+ *     Copyright 2002 Hewlett-Packard Company
+
+ *  2.6 version of this driver inspired by:
+ *     (drivers/mmc/wbsd.c) Copyright (C) 2004-2005 Pierre Ossman,
+ *     All Rights Reserved.
+ *     (drivers/mmc/pxa.c) Copyright (C) 2003 Russell King,
+ *     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.
+ */
+
+/* Why is a timer used to detect insert events?
+ *
+ * From the AU1100 MMC application guide:
+ * If the Au1100-based design is intended to support both MultiMediaCards
+ * and 1- or 4-data bit SecureDigital cards, then the solution is to
+ * connect a weak (560KOhm) pull-up resistor to connector pin 1.
+ * In doing so, a MMC card never enters SPI-mode communications,
+ * but now the SecureDigital card-detect feature of CD/DAT3 is ineffective
+ * (the low to high transition will not occur).
+ *
+ * So we use the timer to check the status manually.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/protocol.h>
+#include <asm/io.h>
+#include <asm/mach-au1x00/au1000.h>
+#include <asm/mach-au1x00/au1xxx_dbdma.h>
+#include <asm/mach-au1x00/au1100_mmc.h>
+#include <asm/scatterlist.h>
+
+#include <au1xxx.h>
+#include "au1xmmc.h"
+
+#define DRIVER_NAME "au1xxx-mmc"
+
+/* Set this to enable special debugging macros */
+/* #define MMC_DEBUG */
+
+#ifdef MMC_DEBUG
+#define DEBUG(fmt, idx, args...) printk("au1xx(%d): DEBUG: " fmt, idx, ##args)
+#else
+#define DEBUG(fmt, idx, args...)
+#endif
+
+const struct {
+        u32 iobase;
+        u32 tx_devid, rx_devid;
+        u16 bcsrpwr;
+        u16 bcsrstatus;
+        u16 wpstatus;
+} au1xmmc_card_table[] = {
+        { SD0_BASE, DSCR_CMD0_SDMS_TX0, DSCR_CMD0_SDMS_RX0,
+          BCSR_BOARD_SD0PWR, BCSR_INT_SD0INSERT, BCSR_STATUS_SD0WP },
+#ifndef CONFIG_MIPS_DB1200
+        { SD1_BASE, DSCR_CMD0_SDMS_TX1, DSCR_CMD0_SDMS_RX1,
+          BCSR_BOARD_DS1PWR, BCSR_INT_SD1INSERT, BCSR_STATUS_SD1WP }
+#endif
+};
+
+#define AU1XMMC_CONTROLLER_COUNT \
+        (sizeof(au1xmmc_card_table) / sizeof(au1xmmc_card_table[0]))
+
+/* This array stores pointers for the hosts (used by the IRQ handler) */
+struct au1xmmc_host *au1xmmc_hosts[AU1XMMC_CONTROLLER_COUNT];
+static int dma = 1;
+
+#ifdef MODULE
+MODULE_PARM(dma, "i");
+MODULE_PARM_DESC(dma, "Use DMA engine for data transfers (0 = disabled)");
+#endif
+
+static inline void IRQ_ON(struct au1xmmc_host *host, u32 mask)
+{
+        u32 val = au_readl(HOST_CONFIG(host));
+        val |= mask;
+        au_writel(val, HOST_CONFIG(host));
+        au_sync();
+}
+
+static inline void FLUSH_FIFO(struct au1xmmc_host *host)
+{
+        u32 val = au_readl(HOST_CONFIG2(host));
+
+        au_writel(val | SD_CONFIG2_FF, HOST_CONFIG2(host));
+        au_sync_delay(1);
+
+        /* SEND_STOP will turn off clock control - this re-enables it */
+        val &= ~SD_CONFIG2_DF;
+
+        au_writel(val, HOST_CONFIG2(host));
+        au_sync();
+}
+
+static inline void IRQ_OFF(struct au1xmmc_host *host, u32 mask)
+{
+        u32 val = au_readl(HOST_CONFIG(host));
+        val &= ~mask;
+        au_writel(val, HOST_CONFIG(host));
+        au_sync();
+}
+
+static inline void SEND_STOP(struct au1xmmc_host *host)
+{
+
+        /* We know the value of CONFIG2, so avoid a read we don't need */
+        u32 mask = SD_CONFIG2_EN;
+
+        WARN_ON(host->status != HOST_S_DATA);
+        host->status = HOST_S_STOP;
+
+        au_writel(mask | SD_CONFIG2_DF, HOST_CONFIG2(host));
+        au_sync();
+
+        /* Send the stop commmand */
+        au_writel(STOP_CMD, HOST_CMD(host));
+}
+
+static void au1xmmc_set_power(struct au1xmmc_host *host, int state)
+{
+
+        u32 val = au1xmmc_card_table[host->id].bcsrpwr;
+
+        bcsr->board &= ~val;
+        if (state) bcsr->board |= val;
+
+        au_sync_delay(1);
+}
+
+static inline int au1xmmc_card_inserted(struct au1xmmc_host *host)
+{
+        return (bcsr->sig_status & au1xmmc_card_table[host->id].bcsrstatus)
+                ? 1 : 0;
+}
+
+static inline int au1xmmc_card_readonly(struct au1xmmc_host *host)
+{
+        return (bcsr->status & au1xmmc_card_table[host->id].wpstatus)
+                ? 1 : 0;
+}
+
+static void au1xmmc_finish_request(struct au1xmmc_host *host)
+{
+
+        struct mmc_request *mrq = host->mrq;
+
+        host->mrq = NULL;
+        host->flags &= HOST_F_ACTIVE;
+
+        host->dma.len = 0;
+        host->dma.dir = 0;
+
+        host->pio.index  = 0;
+        host->pio.offset = 0;
+        host->pio.len = 0;
+
+        host->status = HOST_S_IDLE;
+
+        bcsr->disk_leds |= (1 << 8);
+
+        mmc_request_done(host->mmc, mrq);
+}
+
+static void au1xmmc_tasklet_finish(unsigned long param)
+{
+        struct au1xmmc_host *host = (struct au1xmmc_host *) param;
+        au1xmmc_finish_request(host);
+}
+
+static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
+                                struct mmc_command *cmd)
+{
+
+        u32 mmccmd = (cmd->opcode << SD_CMD_CI_SHIFT);
+
+        switch(cmd->flags) {
+        case MMC_RSP_R1:
+                mmccmd |= SD_CMD_RT_1;
+                break;
+        case MMC_RSP_R1B:
+                mmccmd |= SD_CMD_RT_1B;
+                break;
+        case MMC_RSP_R2:
+                mmccmd |= SD_CMD_RT_2;
+                break;
+        case MMC_RSP_R3:
+                mmccmd |= SD_CMD_RT_3;
+                break;
+        }
+
+        switch(cmd->opcode) {
+        case MMC_READ_SINGLE_BLOCK:
+        case SD_APP_SEND_SCR:
+                mmccmd |= SD_CMD_CT_2;
+                break;
+        case MMC_READ_MULTIPLE_BLOCK:
+                mmccmd |= SD_CMD_CT_4;
+                break;
+        case MMC_WRITE_BLOCK:
+                mmccmd |= SD_CMD_CT_1;
+                break;
+
+        case MMC_WRITE_MULTIPLE_BLOCK:
+                mmccmd |= SD_CMD_CT_3;
+                break;
+        case MMC_STOP_TRANSMISSION:
+                mmccmd |= SD_CMD_CT_7;
+                break;
+        }
+
+        au_writel(cmd->arg, HOST_CMDARG(host));
+        au_sync();
+
+        if (wait)
+                IRQ_OFF(host, SD_CONFIG_CR);
+
+        au_writel((mmccmd | SD_CMD_GO), HOST_CMD(host));
+        au_sync();
+
+        /* Wait for the command to go on the line */
+
+        while(1) {
+                if (!(au_readl(HOST_CMD(host)) & SD_CMD_GO))
+                        break;
+        }
+
+        /* Wait for the command to come back */
+
+        if (wait) {
+                u32 status = au_readl(HOST_STATUS(host));
+
+                while(!(status & SD_STATUS_CR))
+                        status = au_readl(HOST_STATUS(host));
+
+                /* Clear the CR status */
+                au_writel(SD_STATUS_CR, HOST_STATUS(host));
+
+                IRQ_ON(host, SD_CONFIG_CR);
+        }
+
+        return MMC_ERR_NONE;
+}
+
+static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
+{
+
+        struct mmc_request *mrq = host->mrq;
+        struct mmc_data *data;
+        u32 crc;
+
+        WARN_ON(host->status != HOST_S_DATA && host->status != HOST_S_STOP);
+
+        if (host->mrq == NULL)
+                return;
+
+        data = mrq->cmd->data;
+
+        if (status == 0)
+                status = au_readl(HOST_STATUS(host));
+
+        /* The transaction is really over when the SD_STATUS_DB bit is clear */
+
+        while((host->flags & HOST_F_XMIT) && (status & SD_STATUS_DB))
+                status = au_readl(HOST_STATUS(host));
+
+        data->error = MMC_ERR_NONE;
+        dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma.dir);
+
+        /* Process any errors */
+
+        crc = (status & (SD_STATUS_WC | SD_STATUS_RC));
+        if (host->flags & HOST_F_XMIT)
+                crc |= ((status & 0x07) == 0x02) ? 0 : 1;
+
+        if (crc)
+                data->error = MMC_ERR_BADCRC;
+
+        /* Clear the CRC bits */
+        au_writel(SD_STATUS_WC | SD_STATUS_RC, HOST_STATUS(host));
+
+        data->bytes_xfered = 0;
+
+        if (data->error == MMC_ERR_NONE) {
+                if (host->flags & HOST_F_DMA) {
+                        u32 chan = DMA_CHANNEL(host);
+
+                        chan_tab_t *c = *((chan_tab_t **) chan);
+                        au1x_dma_chan_t *cp = c->chan_ptr;
+                        data->bytes_xfered = cp->ddma_bytecnt;
+                }
+                else
+                        data->bytes_xfered =
+                                (data->blocks * (1 << data->blksz_bits)) -
+                                host->pio.len;
+        }
+
+        au1xmmc_finish_request(host);
+}
+
+static void au1xmmc_tasklet_data(unsigned long param)
+{
+        struct au1xmmc_host *host = (struct au1xmmc_host *) param;
+
+        u32 status = au_readl(HOST_STATUS(host));
+        au1xmmc_data_complete(host, status);
+}
+
+#define AU1XMMC_MAX_TRANSFER 8
+
+static void au1xmmc_send_pio(struct au1xmmc_host *host)
+{
+
+        struct mmc_data *data = 0;
+        int sg_len, max, count = 0;
+        unsigned char *sg_ptr;
+        u32 status = 0;
+        struct scatterlist *sg;
+
+        data = host->mrq->data;
+
+        if (!(host->flags & HOST_F_XMIT))
+                return;
+
+        /* This is the pointer to the data buffer */
+        sg = &data->sg[host->pio.index];
+        sg_ptr = page_address(sg->page) + sg->offset + host->pio.offset;
+
+        /* This is the space left inside the buffer */
+        sg_len = data->sg[host->pio.index].length - host->pio.offset;
+
+        /* Check to if we need less then the size of the sg_buffer */
+
+        max = (sg_len > host->pio.len) ? host->pio.len : sg_len;
+        if (max > AU1XMMC_MAX_TRANSFER) max = AU1XMMC_MAX_TRANSFER;
+
+        for(count = 0; count < max; count++ ) {
+                unsigned char val;
+
+                status = au_readl(HOST_STATUS(host));
+
+                if (!(status & SD_STATUS_TH))
+                        break;
+
+                val = *sg_ptr++;
+
+                au_writel((unsigned long) val, HOST_TXPORT(host));
+                au_sync();
+        }
+
+        host->pio.len -= count;
+        host->pio.offset += count;
+
+        if (count == sg_len) {
+                host->pio.index++;
+                host->pio.offset = 0;
+        }
+
+        if (host->pio.len == 0) {
+                IRQ_OFF(host, SD_CONFIG_TH);
+
+                if (host->flags & HOST_F_STOP)
+                        SEND_STOP(host);
+
+                tasklet_schedule(&host->data_task);
+        }
+}
+
+static void au1xmmc_receive_pio(struct au1xmmc_host *host)
+{
+
+        struct mmc_data *data = 0;
+        int sg_len = 0, max = 0, count = 0;
+        unsigned char *sg_ptr = 0;
+        u32 status = 0;
+        struct scatterlist *sg;
+
+        data = host->mrq->data;
+
+        if (!(host->flags & HOST_F_RECV))
+                return;
+
+        max = host->pio.len;
+
+        if (host->pio.index < host->dma.len) {
+                sg = &data->sg[host->pio.index];
+                sg_ptr = page_address(sg->page) + sg->offset + host->pio.offset;
+
+                /* This is the space left inside the buffer */
+                sg_len = sg_dma_len(&data->sg[host->pio.index]) - host->pio.offset;
+
+                /* Check to if we need less then the size of the sg_buffer */
+                if (sg_len < max) max = sg_len;
+        }
+
+        if (max > AU1XMMC_MAX_TRANSFER)
+                max = AU1XMMC_MAX_TRANSFER;
+
+        for(count = 0; count < max; count++ ) {
+                u32 val;
+                status = au_readl(HOST_STATUS(host));
+
+                if (!(status & SD_STATUS_NE))
+                        break;
+
+                if (status & SD_STATUS_RC) {
+                        DEBUG("RX CRC Error [%d + %d].\n", host->id,
+                                        host->pio.len, count);
+                        break;
+                }
+
+                if (status & SD_STATUS_RO) {
+                        DEBUG("RX Overrun [%d + %d]\n", host->id,
+                                        host->pio.len, count);
+                        break;
+                }
+                else if (status & SD_STATUS_RU) {
+                        DEBUG("RX Underrun [%d + %d]\n", host->id,
+                                        host->pio.len,  count);
+                        break;
+                }
+
+                val = au_readl(HOST_RXPORT(host));
+
+                if (sg_ptr)
+                        *sg_ptr++ = (unsigned char) (val & 0xFF);
+        }
+
+        host->pio.len -= count;
+        host->pio.offset += count;
+
+        if (sg_len && count == sg_len) {
+                host->pio.index++;
+                host->pio.offset = 0;
+        }
+
+        if (host->pio.len == 0) {
+                //IRQ_OFF(host, SD_CONFIG_RA | SD_CONFIG_RF);
+                IRQ_OFF(host, SD_CONFIG_NE);
+
+                if (host->flags & HOST_F_STOP)
+                        SEND_STOP(host);
+
+                tasklet_schedule(&host->data_task);
+        }
+}
+
+/* static void au1xmmc_cmd_complete
+   This is called when a command has been completed - grab the response
+   and check for errors.  Then start the data transfer if it is indicated.
+*/
+
+static void au1xmmc_cmd_complete(struct au1xmmc_host *host, u32 status)
+{
+
+        struct mmc_request *mrq = host->mrq;
+        struct mmc_command *cmd;
+        int trans;
+
+        if (!host->mrq)
+                return;
+
+        cmd = mrq->cmd;
+        cmd->error = MMC_ERR_NONE;
+
+        if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_SHORT) {
+
+                /* Techincally, we should be getting all 48 bits of the response
+                 * (SD_RESP1 + SD_RESP2), but because our response omits the CRC,
+                 * our data ends up being shifted 8 bits to the right.  In this case,
+                 * that means that the OSR data starts at bit 31, so we can just
+                 * read RESP0 and return that
+                 */
+
+                cmd->resp[0] = au_readl(host->iobase + SD_RESP0);
+        }
+        else if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_LONG) {
+                u32 r[4];
+                int i;
+
+                r[0] = au_readl(host->iobase + SD_RESP3);
+                r[1] = au_readl(host->iobase + SD_RESP2);
+                r[2] = au_readl(host->iobase + SD_RESP1);
+                r[3] = au_readl(host->iobase + SD_RESP0);
+
+                /* The CRC is omitted from the response, so really we only got
+                 * 120 bytes, but the engine expects 128 bits, so we have to shift
+                 * things up
+                 */
+
+                for(i = 0; i < 4; i++) {
+                        cmd->resp[i] = (r[i] & 0x00FFFFFF) << 8;
+                        if (i != 3) cmd->resp[i] |= (r[i + 1] & 0xFF000000) >> 24;
+                }
+        }
+
+        /* Figure out errors */
+
+        if (status & (SD_STATUS_SC | SD_STATUS_WC | SD_STATUS_RC))
+                cmd->error = MMC_ERR_BADCRC;
+
+        trans = host->flags & (HOST_F_XMIT | HOST_F_RECV);
+
+        if (!trans || cmd->error != MMC_ERR_NONE) {
+
+                IRQ_OFF(host, SD_CONFIG_TH | SD_CONFIG_RA|SD_CONFIG_RF);
+                tasklet_schedule(&host->finish_task);
+                return;
+        }
+
+        host->status = HOST_S_DATA;
+
+        if (host->flags & HOST_F_DMA) {
+                u32 channel = DMA_CHANNEL(host);
+
+                /* Start the DMA as soon as the buffer gets something in it */
+
+                if (host->flags & HOST_F_RECV) {
+                        u32 mask = SD_STATUS_DB | SD_STATUS_NE;
+
+                        while((status & mask) != mask)
+                                status = au_readl(HOST_STATUS(host));
+                }
+
+                au1xxx_dbdma_start(channel);
+        }
+}
+
+static void au1xmmc_set_clock(struct au1xmmc_host *host, int rate)
+{
+
+        unsigned int pbus = get_au1x00_speed();
+        unsigned int divisor;
+        u32 config;
+
+        /* From databook:
+           divisor = ((((cpuclock / sbus_divisor) / 2) / mmcclock) / 2) - 1
+        */
+
+        pbus /= ((au_readl(SYS_POWERCTRL) & 0x3) + 2);
+        pbus /= 2;
+
+        divisor = ((pbus / rate) / 2) - 1;
+
+        config = au_readl(HOST_CONFIG(host));
+
+        config &= ~(SD_CONFIG_DIV);
+        config |= (divisor & SD_CONFIG_DIV) | SD_CONFIG_DE;
+
+        au_writel(config, HOST_CONFIG(host));
+        au_sync();
+}
+
+static int
+au1xmmc_prepare_data(struct au1xmmc_host *host, struct mmc_data *data)
+{
+
+        int datalen = data->blocks * (1 << data->blksz_bits);
+
+        if (dma != 0)
+                host->flags |= HOST_F_DMA;
+
+        if (data->flags & MMC_DATA_READ)
+                host->flags |= HOST_F_RECV;
+        else
+                host->flags |= HOST_F_XMIT;
+
+        if (host->mrq->stop)
+                host->flags |= HOST_F_STOP;
+
+        host->dma.dir = DMA_BIDIRECTIONAL;
+
+        host->dma.len = dma_map_sg(mmc_dev(host->mmc), data->sg,
+                                   data->sg_len, host->dma.dir);
+
+        if (host->dma.len == 0)
+                return MMC_ERR_TIMEOUT;
+
+        au_writel((1 << data->blksz_bits) - 1, HOST_BLKSIZE(host));
+
+        if (host->flags & HOST_F_DMA) {
+                int i;
+                u32 channel = DMA_CHANNEL(host);
+
+                au1xxx_dbdma_stop(channel);
+
+                for(i = 0; i < host->dma.len; i++) {
+                        u32 ret = 0, flags = DDMA_FLAGS_NOIE;
+                        struct scatterlist *sg = &data->sg[i];
+                        int sg_len = sg->length;
+
+                        int len = (datalen > sg_len) ? sg_len : datalen;
+
+                        if (i == host->dma.len - 1)
+                                flags = DDMA_FLAGS_IE;
+
+                        if (host->flags & HOST_F_XMIT){
+                                ret = au1xxx_dbdma_put_source_flags(channel,
+                                        (void *) (page_address(sg->page) +
+                                                  sg->offset),
+                                        len, flags);
+                        }
+                        else {
+                                ret = au1xxx_dbdma_put_dest_flags(channel,
+                                        (void *) (page_address(sg->page) +
+                                                  sg->offset),
+                                        len, flags);
+                        }
+
+                        if (!ret)
+                                goto dataerr;
+
+                        datalen -= len;
+                }
+        }
+        else {
+                host->pio.index = 0;
+                host->pio.offset = 0;
+                host->pio.len = datalen;
+
+                if (host->flags & HOST_F_XMIT)
+                        IRQ_ON(host, SD_CONFIG_TH);
+                else
+                        IRQ_ON(host, SD_CONFIG_NE);
+                        //IRQ_ON(host, SD_CONFIG_RA|SD_CONFIG_RF);
+        }
+
+        return MMC_ERR_NONE;
+
+ dataerr:
+        dma_unmap_sg(mmc_dev(host->mmc),data->sg,data->sg_len,host->dma.dir);
+        return MMC_ERR_TIMEOUT;
+}
+
+/* static void au1xmmc_request
+   This actually starts a command or data transaction
+*/
+
+static void au1xmmc_request(struct mmc_host* mmc, struct mmc_request* mrq)
+{
+
+        struct au1xmmc_host *host = mmc_priv(mmc);
+        int ret = MMC_ERR_NONE;
+
+        WARN_ON(irqs_disabled());
+        WARN_ON(host->status != HOST_S_IDLE);
+
+        host->mrq = mrq;
+        host->status = HOST_S_CMD;
+
+        bcsr->disk_leds &= ~(1 << 8);
+
+        if (mrq->data) {
+                FLUSH_FIFO(host);
+                ret = au1xmmc_prepare_data(host, mrq->data);
+        }
+
+        if (ret == MMC_ERR_NONE)
+                ret = au1xmmc_send_command(host, 0, mrq->cmd);
+
+        if (ret != MMC_ERR_NONE) {
+                mrq->cmd->error = ret;
+                au1xmmc_finish_request(host);
+        }
+}
+
+static void au1xmmc_reset_controller(struct au1xmmc_host *host)
+{
+
+        /* Apply the clock */
+        au_writel(SD_ENABLE_CE, HOST_ENABLE(host));
+        au_sync_delay(1);
+
+        au_writel(SD_ENABLE_R | SD_ENABLE_CE, HOST_ENABLE(host));
+        au_sync_delay(5);
+
+        au_writel(~0, HOST_STATUS(host));
+        au_sync();
+
+        au_writel(0, HOST_BLKSIZE(host));
+        au_writel(0x001fffff, HOST_TIMEOUT(host));
+        au_sync();
+
+        au_writel(SD_CONFIG2_EN, HOST_CONFIG2(host));
+        au_sync();
+
+        au_writel(SD_CONFIG2_EN | SD_CONFIG2_FF, HOST_CONFIG2(host));
+        au_sync_delay(1);
+
+        au_writel(SD_CONFIG2_EN, HOST_CONFIG2(host));
+        au_sync();
+
+        /* Configure interrupts */
+        au_writel(AU1XMMC_INTERRUPTS, HOST_CONFIG(host));
+        au_sync();
+}
+
+
+static void au1xmmc_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
+{
+        struct au1xmmc_host *host = mmc_priv(mmc);
+
+        DEBUG("set_ios (power=%u, clock=%uHz, vdd=%u, mode=%u)\n",
+              host->id, ios->power_mode, ios->clock, ios->vdd,
+              ios->bus_mode);
+
+        if (ios->power_mode == MMC_POWER_OFF)
+                au1xmmc_set_power(host, 0);
+        else if (ios->power_mode == MMC_POWER_ON) {
+                au1xmmc_set_power(host, 1);
+        }
+
+        if (ios->clock && ios->clock != host->clock) {
+                au1xmmc_set_clock(host, ios->clock);
+                host->clock = ios->clock;
+        }
+}
+
+static void au1xmmc_dma_callback(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct au1xmmc_host *host = (struct au1xmmc_host *) dev_id;
+        u32 status;
+
+        /* Avoid spurious interrupts */
+
+        if (!host->mrq)
+                return;
+
+        if (host->flags & HOST_F_STOP)
+                SEND_STOP(host);
+
+        tasklet_schedule(&host->data_task);
+}
+
+#define STATUS_TIMEOUT (SD_STATUS_RAT | SD_STATUS_DT)
+#define STATUS_DATA_IN  (SD_STATUS_NE)
+#define STATUS_DATA_OUT (SD_STATUS_TH)
+
+static irqreturn_t au1xmmc_irq(int irq, void *dev_id, struct pt_regs *regs)
+{
+
+        u32 status;
+        int i, ret = 0;
+
+        disable_irq(AU1100_SD_IRQ);
+
+        for(i = 0; i < AU1XMMC_CONTROLLER_COUNT; i++) {
+                struct au1xmmc_host * host = au1xmmc_hosts[i];
+                u32 handled = 1;
+
+                status = au_readl(HOST_STATUS(host));
+
+                if (host->mrq && (status & STATUS_TIMEOUT)) {
+                        if (status & SD_STATUS_RAT)
+                                host->mrq->cmd->error = MMC_ERR_TIMEOUT;
+
+                        else if (status & SD_STATUS_DT)
+                                host->mrq->data->error = MMC_ERR_TIMEOUT;
+
+                        /* In PIO mode, interrupts might still be enabled */
+                        IRQ_OFF(host, SD_CONFIG_NE | SD_CONFIG_TH);
+
+                        //IRQ_OFF(host, SD_CONFIG_TH|SD_CONFIG_RA|SD_CONFIG_RF);
+                        tasklet_schedule(&host->finish_task);
+                }
+#if 0
+                else if (status & SD_STATUS_DD) {
+
+                        /* Sometimes we get a DD before a NE in PIO mode */
+
+                        if (!(host->flags & HOST_F_DMA) &&
+                                        (status & SD_STATUS_NE))
+                                au1xmmc_receive_pio(host);
+                        else {
+                                au1xmmc_data_complete(host, status);
+                                //tasklet_schedule(&host->data_task);
+                        }
+                }
+#endif
+                else if (status & (SD_STATUS_CR)) {
+                        if (host->status == HOST_S_CMD)
+                                au1xmmc_cmd_complete(host,status);
+                }
+                else if (!(host->flags & HOST_F_DMA)) {
+                        if ((host->flags & HOST_F_XMIT) &&
+                            (status & STATUS_DATA_OUT))
+                                au1xmmc_send_pio(host);
+                        else if ((host->flags & HOST_F_RECV) &&
+                            (status & STATUS_DATA_IN))
+                                au1xmmc_receive_pio(host);
+                }
+                else if (status & 0x203FBC70) {
+                        DEBUG("Unhandled status %8.8x\n", host->id, status);
+                        handled = 0;
+                }
+
+                au_writel(status, HOST_STATUS(host));
+                au_sync();
+
+                ret |= handled;
+        }
+
+        enable_irq(AU1100_SD_IRQ);
+        return ret;
+}
+
+static void au1xmmc_poll_event(unsigned long arg)
+{
+        struct au1xmmc_host *host = (struct au1xmmc_host *) arg;
+
+        int card = au1xmmc_card_inserted(host);
+        int controller = (host->flags & HOST_F_ACTIVE) ? 1 : 0;
+
+        if (card != controller) {
+                host->flags &= ~HOST_F_ACTIVE;
+                if (card) host->flags |= HOST_F_ACTIVE;
+                mmc_detect_change(host->mmc, 0);
+        }
+
+        if (host->mrq != NULL) {
+                u32 status = au_readl(HOST_STATUS(host));
+                DEBUG("PENDING - %8.8x\n", host->id, status);
+        }
+
+        mod_timer(&host->timer, jiffies + AU1XMMC_DETECT_TIMEOUT);
+}
+
+static dbdev_tab_t au1xmmc_mem_dbdev =
+{
+        DSCR_CMD0_ALWAYS, DEV_FLAGS_ANYUSE, 0, 8, 0x00000000, 0, 0
+};
+
+static void au1xmmc_init_dma(struct au1xmmc_host *host)
+{
+
+        u32 rxchan, txchan;
+
+        int txid = au1xmmc_card_table[host->id].tx_devid;
+        int rxid = au1xmmc_card_table[host->id].rx_devid;
+
+        /* DSCR_CMD0_ALWAYS has a stride of 32 bits, we need a stride
+           of 8 bits.  And since devices are shared, we need to create
+           our own to avoid freaking out other devices
+        */
+
+        int memid = au1xxx_ddma_add_device(&au1xmmc_mem_dbdev);
+
+        txchan = au1xxx_dbdma_chan_alloc(memid, txid,
+                                         au1xmmc_dma_callback, (void *) host);
+
+        rxchan = au1xxx_dbdma_chan_alloc(rxid, memid,
+                                         au1xmmc_dma_callback, (void *) host);
+
+        au1xxx_dbdma_set_devwidth(txchan, 8);
+        au1xxx_dbdma_set_devwidth(rxchan, 8);
+
+        au1xxx_dbdma_ring_alloc(txchan, AU1XMMC_DESCRIPTOR_COUNT);
+        au1xxx_dbdma_ring_alloc(rxchan, AU1XMMC_DESCRIPTOR_COUNT);
+
+        host->tx_chan = txchan;
+        host->rx_chan = rxchan;
+}
+
+struct mmc_host_ops au1xmmc_ops = {
+        .request        = au1xmmc_request,
+        .set_ios        = au1xmmc_set_ios,
+};
+
+static int au1xmmc_probe(struct device *dev)
+{
+
+        int i, ret = 0;
+
+        /* THe interrupt is shared among all controllers */
+        ret = request_irq(AU1100_SD_IRQ, au1xmmc_irq, SA_INTERRUPT, "MMC", 0);
+
+        if (ret) {
+                printk(DRIVER_NAME "ERROR: Couldn't get int %d: %d\n",
+                                AU1100_SD_IRQ, ret);
+                return -ENXIO;
+        }
+
+        disable_irq(AU1100_SD_IRQ);
+
+        for(i = 0; i < AU1XMMC_CONTROLLER_COUNT; i++) {
+                struct mmc_host *mmc = mmc_alloc_host(sizeof(struct au1xmmc_host), dev);
+                struct au1xmmc_host *host = 0;
+
+                if (!mmc) {
+                        printk(DRIVER_NAME "ERROR: no mem for host %d\n", i);
+                        au1xmmc_hosts[i] = 0;
+                        continue;
+                }
+
+                mmc->ops = &au1xmmc_ops;
+
+                mmc->f_min =   450000;
+                mmc->f_max = 24000000;
+
+                mmc->max_seg_size = AU1XMMC_DESCRIPTOR_SIZE;
+                mmc->max_phys_segs = AU1XMMC_DESCRIPTOR_COUNT;
+
+                mmc->ocr_avail = AU1XMMC_OCR;
+
+                host = mmc_priv(mmc);
+                host->mmc = mmc;
+
+                host->id = i;
+                host->iobase = au1xmmc_card_table[host->id].iobase;
+                host->clock = 0;
+                host->power_mode = MMC_POWER_OFF;
+
+                host->flags = au1xmmc_card_inserted(host) ? HOST_F_ACTIVE : 0;
+                host->status = HOST_S_IDLE;
+
+                init_timer(&host->timer);
+
+                host->timer.function = au1xmmc_poll_event;
+                host->timer.data = (unsigned long) host;
+                host->timer.expires = jiffies + AU1XMMC_DETECT_TIMEOUT;
+
+                tasklet_init(&host->data_task, au1xmmc_tasklet_data,
+                                (unsigned long) host);
+
+                tasklet_init(&host->finish_task, au1xmmc_tasklet_finish,
+                                (unsigned long) host);
+
+                spin_lock_init(&host->lock);
+
+                if (dma != 0)
+                        au1xmmc_init_dma(host);
+
+                au1xmmc_reset_controller(host);
+
+                mmc_add_host(mmc);
+                au1xmmc_hosts[i] = host;
+
+                add_timer(&host->timer);
+
+                printk(KERN_INFO DRIVER_NAME ": MMC Controller %d set up at %8.8X (mode=%s)\n",
+                       host->id, host->iobase, dma ? "dma" : "pio");
+        }
+
+        enable_irq(AU1100_SD_IRQ);
+
+        return 0;
+}
+
+static int au1xmmc_remove(struct device *dev)
+{
+
+        int i;
+
+        disable_irq(AU1100_SD_IRQ);
+
+        for(i = 0; i < AU1XMMC_CONTROLLER_COUNT; i++) {
+                struct au1xmmc_host *host = au1xmmc_hosts[i];
+                if (!host) continue;
+
+                tasklet_kill(&host->data_task);
+                tasklet_kill(&host->finish_task);
+
+                del_timer_sync(&host->timer);
+                au1xmmc_set_power(host, 0);
+
+                mmc_remove_host(host->mmc);
+
+                au1xxx_dbdma_chan_free(host->tx_chan);
+                au1xxx_dbdma_chan_free(host->rx_chan);
+
+                au_writel(0x0, HOST_ENABLE(host));
+                au_sync();
+        }
+
+        free_irq(AU1100_SD_IRQ, 0);
+        return 0;
+}
+
+static struct device_driver au1xmmc_driver = {
+        .name          = DRIVER_NAME,
+        .bus           = &platform_bus_type,
+        .probe         = au1xmmc_probe,
+        .remove        = au1xmmc_remove,
+        .suspend       = NULL,
+        .resume        = NULL
+};
+
+static int __init au1xmmc_init(void)
+{
+        return driver_register(&au1xmmc_driver);
+}
+
+static void __exit au1xmmc_exit(void)
+{
+        driver_unregister(&au1xmmc_driver);
+}
+
+module_init(au1xmmc_init);
+module_exit(au1xmmc_exit);
+
+#ifdef MODULE
+MODULE_AUTHOR("Advanced Micro Devices, Inc");
+MODULE_DESCRIPTION("MMC/SD driver for the Alchemy Au1XXX");
+MODULE_LICENSE("GPL");
+#endif
+
diff --git a/drivers/mmc/au1xmmc.h b/drivers/mmc/au1xmmc.h
new file mode 100644
index 000000000000..341cbdf0baca
--- /dev/null
+++ b/drivers/mmc/au1xmmc.h
@@ -0,0 +1,96 @@
+#ifndef _AU1XMMC_H_
+#define _AU1XMMC_H_
+
+/* Hardware definitions */
+
+#define AU1XMMC_DESCRIPTOR_COUNT 1
+#define AU1XMMC_DESCRIPTOR_SIZE  2048
+
+#define AU1XMMC_OCR ( MMC_VDD_27_28 | MMC_VDD_28_29 | MMC_VDD_29_30  | \
+                      MMC_VDD_30_31 | MMC_VDD_31_32 | MMC_VDD_32_33  | \
+                      MMC_VDD_33_34 | MMC_VDD_34_35 | MMC_VDD_35_36)
+
+/* Easy access macros */
+
+#define HOST_STATUS(h)  ((h)->iobase + SD_STATUS)
+#define HOST_CONFIG(h)  ((h)->iobase + SD_CONFIG)
+#define HOST_ENABLE(h)  ((h)->iobase + SD_ENABLE)
+#define HOST_TXPORT(h)  ((h)->iobase + SD_TXPORT)
+#define HOST_RXPORT(h)  ((h)->iobase + SD_RXPORT)
+#define HOST_CMDARG(h)  ((h)->iobase + SD_CMDARG)
+#define HOST_BLKSIZE(h) ((h)->iobase + SD_BLKSIZE)
+#define HOST_CMD(h)     ((h)->iobase + SD_CMD)
+#define HOST_CONFIG2(h) ((h)->iobase + SD_CONFIG2)
+#define HOST_TIMEOUT(h) ((h)->iobase + SD_TIMEOUT)
+#define HOST_DEBUG(h)   ((h)->iobase + SD_DEBUG)
+
+#define DMA_CHANNEL(h) \
+        ( ((h)->flags & HOST_F_XMIT) ? (h)->tx_chan : (h)->rx_chan)
+
+/* This gives us a hard value for the stop command that we can write directly
+ * to the command register
+ */
+
+#define STOP_CMD (SD_CMD_RT_1B|SD_CMD_CT_7|(0xC << SD_CMD_CI_SHIFT)|SD_CMD_GO)
+
+/* This is the set of interrupts that we configure by default */
+
+#if 0
+#define AU1XMMC_INTERRUPTS (SD_CONFIG_SC | SD_CONFIG_DT | SD_CONFIG_DD | \
+                SD_CONFIG_RAT | SD_CONFIG_CR | SD_CONFIG_I)
+#endif
+
+#define AU1XMMC_INTERRUPTS (SD_CONFIG_SC | SD_CONFIG_DT | \
+                SD_CONFIG_RAT | SD_CONFIG_CR | SD_CONFIG_I)
+/* The poll event (looking for insert/remove events runs twice a second */
+#define AU1XMMC_DETECT_TIMEOUT (HZ/2)
+
+struct au1xmmc_host {
+  struct mmc_host *mmc;
+  struct mmc_request *mrq;
+
+  u32 id;
+
+  u32 flags;
+  u32 iobase;
+  u32 clock;
+  u32 bus_width;
+  u32 power_mode;
+
+  int status;
+
+   struct {
+           int len;
+           int dir;
+  } dma;
+
+   struct {
+           int index;
+           int offset;
+           int len;
+  } pio;
+
+  u32 tx_chan;
+  u32 rx_chan;
+
+  struct timer_list timer;
+  struct tasklet_struct finish_task;
+  struct tasklet_struct data_task;
+
+  spinlock_t lock;
+};
+
+/* Status flags used by the host structure */
+
+#define HOST_F_XMIT   0x0001
+#define HOST_F_RECV   0x0002
+#define HOST_F_DMA    0x0010
+#define HOST_F_ACTIVE 0x0100
+#define HOST_F_STOP   0x1000
+
+#define HOST_S_IDLE   0x0001
+#define HOST_S_CMD    0x0002
+#define HOST_S_DATA   0x0003
+#define HOST_S_STOP   0x0004
+
+#endif
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index fa83f15fdf16..9b629856c735 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -85,6 +85,12 @@ static void mmc_blk_put(struct mmc_blk_data *md)
         up(&open_lock);
 }
 
+static inline int mmc_blk_readonly(struct mmc_card *card)
+{
+        return mmc_card_readonly(card) ||
+               !(card->csd.cmdclass & CCC_BLOCK_WRITE);
+}
+
 static int mmc_blk_open(struct inode *inode, struct file *filp)
 {
         struct mmc_blk_data *md;
@@ -97,7 +103,7 @@ static int mmc_blk_open(struct inode *inode, struct file *filp)
                 ret = 0;
 
                 if ((filp->f_mode & FMODE_WRITE) &&
-                        mmc_card_readonly(md->queue.card))
+                        mmc_blk_readonly(md->queue.card))
                         ret = -EROFS;
         }
 
@@ -410,7 +416,7 @@ static int mmc_blk_probe(struct mmc_card *card)
         printk(KERN_INFO "%s: %s %s %dKiB %s\n",
                 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
                 (card->csd.capacity << card->csd.read_blkbits) / 1024,
-                mmc_card_readonly(card)?"(ro)":"");
+                mmc_blk_readonly(card)?"(ro)":"");
 
         mmc_set_drvdata(card, md);
         add_disk(md->disk);
diff --git a/drivers/mmc/pxamci.c b/drivers/mmc/pxamci.c
index 4da4a98bd590..f31e247b2cbe 100644
--- a/drivers/mmc/pxamci.c
+++ b/drivers/mmc/pxamci.c
@@ -29,7 +29,6 @@
 
 #include <asm/dma.h>
 #include <asm/io.h>
-#include <asm/irq.h>
 #include <asm/scatterlist.h>
 #include <asm/sizes.h>
 
diff --git a/drivers/mtd/chips/jedec.c b/drivers/mtd/chips/jedec.c
index 62d235a9a4e2..4f6778f3ee3e 100644
--- a/drivers/mtd/chips/jedec.c
+++ b/drivers/mtd/chips/jedec.c
@@ -17,6 +17,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/mtd/jedec.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/mtd.h>
diff --git a/drivers/mtd/devices/lart.c b/drivers/mtd/devices/lart.c
index dfd335e4a2a8..df987a53ed9c 100644
--- a/drivers/mtd/devices/lart.c
+++ b/drivers/mtd/devices/lart.c
@@ -44,6 +44,7 @@
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/errno.h>
+#include <linux/string.h>
 #include <linux/mtd/mtd.h>
 #ifdef HAVE_PARTITIONS
 #include <linux/mtd/partitions.h>
diff --git a/drivers/mtd/devices/phram.c b/drivers/mtd/devices/phram.c
index a423a382095a..765c0179c8df 100644
--- a/drivers/mtd/devices/phram.c
+++ b/drivers/mtd/devices/phram.c
@@ -22,6 +22,7 @@
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <linux/mtd/mtd.h>
 
 #define ERROR(fmt, args...) printk(KERN_ERR "phram: " fmt , ## args)
diff --git a/drivers/mtd/maps/bast-flash.c b/drivers/mtd/maps/bast-flash.c
index 5f248ebe68e0..bfe994e59265 100644
--- a/drivers/mtd/maps/bast-flash.c
+++ b/drivers/mtd/maps/bast-flash.c
@@ -32,8 +32,9 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
-
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
diff --git a/drivers/mtd/maps/ceiva.c b/drivers/mtd/maps/ceiva.c
index da8584a662f4..c68b31dc7e6d 100644
--- a/drivers/mtd/maps/ceiva.c
+++ b/drivers/mtd/maps/ceiva.c
@@ -20,6 +20,7 @@
 #include <linux/ioport.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
diff --git a/drivers/mtd/maps/dc21285.c b/drivers/mtd/maps/dc21285.c
index 938c41f2f056..e5b74169fde6 100644
--- a/drivers/mtd/maps/dc21285.c
+++ b/drivers/mtd/maps/dc21285.c
@@ -13,6 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
diff --git a/drivers/mtd/maps/dilnetpc.c b/drivers/mtd/maps/dilnetpc.c
index 0bc79c93a584..f99519692cb7 100644
--- a/drivers/mtd/maps/dilnetpc.c
+++ b/drivers/mtd/maps/dilnetpc.c
@@ -30,12 +30,15 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <asm/io.h>
+#include <linux/string.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
 #include <linux/mtd/concat.h>
 
+#include <asm/io.h>
+
 /*
 ** The DIL/NetPC keeps its BIOS in two distinct flash blocks.
 ** Destroying any of these blocks transforms the DNPC into
diff --git a/drivers/mtd/maps/epxa10db-flash.c b/drivers/mtd/maps/epxa10db-flash.c
index ab6dbe2b8cce..1df6188926b3 100644
--- a/drivers/mtd/maps/epxa10db-flash.c
+++ b/drivers/mtd/maps/epxa10db-flash.c
@@ -27,12 +27,15 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <asm/io.h>
+#include <linux/slab.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
 
+#include <asm/io.h>
 #include <asm/hardware.h>
+
 #ifdef CONFIG_EPXA10DB
 #define BOARD_NAME "EPXA10DB"
 #else
diff --git a/drivers/mtd/maps/fortunet.c b/drivers/mtd/maps/fortunet.c
index 068bb6a54520..00f7bbe5479e 100644
--- a/drivers/mtd/maps/fortunet.c
+++ b/drivers/mtd/maps/fortunet.c
@@ -7,11 +7,14 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <asm/io.h>
+#include <linux/string.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
 
+#include <asm/io.h>
+
 #define MAX_NUM_REGIONS         4
 #define MAX_NUM_PARTITIONS      8
 
diff --git a/drivers/mtd/maps/ixp2000.c b/drivers/mtd/maps/ixp2000.c
index 6815baee89d7..00b9f67580f1 100644
--- a/drivers/mtd/maps/ixp2000.c
+++ b/drivers/mtd/maps/ixp2000.c
@@ -22,11 +22,14 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
-#include <linux/ioport.h>
-#include <linux/platform_device.h>
 
 #include <asm/io.h>
 #include <asm/hardware.h>
diff --git a/drivers/mtd/maps/ixp4xx.c b/drivers/mtd/maps/ixp4xx.c
index 06e1c7fffed3..733a9297a562 100644
--- a/drivers/mtd/maps/ixp4xx.c
+++ b/drivers/mtd/maps/ixp4xx.c
@@ -20,11 +20,15 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
-#include <linux/ioport.h>
-#include <linux/platform_device.h>
+
 #include <asm/io.h>
 #include <asm/mach/flash.h>
 
diff --git a/drivers/mtd/maps/lubbock-flash.c b/drivers/mtd/maps/lubbock-flash.c
index 1298de475c9a..2337e0c46750 100644
--- a/drivers/mtd/maps/lubbock-flash.c
+++ b/drivers/mtd/maps/lubbock-flash.c
@@ -15,10 +15,13 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/slab.h>
+
 #include <linux/dma-mapping.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
+
 #include <asm/io.h>
 #include <asm/hardware.h>
 #include <asm/arch/pxa-regs.h>
diff --git a/drivers/mtd/maps/mainstone-flash.c b/drivers/mtd/maps/mainstone-flash.c
index 87e93fa60588..da0f8a692628 100644
--- a/drivers/mtd/maps/mainstone-flash.c
+++ b/drivers/mtd/maps/mainstone-flash.c
@@ -16,9 +16,12 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
+
 #include <asm/io.h>
 #include <asm/hardware.h>
 #include <asm/arch/pxa-regs.h>
diff --git a/drivers/mtd/maps/omap-toto-flash.c b/drivers/mtd/maps/omap-toto-flash.c
index 496109071cb1..da36e8dddd17 100644
--- a/drivers/mtd/maps/omap-toto-flash.c
+++ b/drivers/mtd/maps/omap-toto-flash.c
@@ -12,9 +12,9 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
diff --git a/drivers/mtd/maps/omap_nor.c b/drivers/mtd/maps/omap_nor.c
index 9c9f4116e50a..7f370bb794fe 100644
--- a/drivers/mtd/maps/omap_nor.c
+++ b/drivers/mtd/maps/omap_nor.c
@@ -36,6 +36,8 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
+#include <linux/slab.h>
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
diff --git a/drivers/mtd/maps/pci.c b/drivers/mtd/maps/pci.c
index 18dbd3af1eaa..d9c64e99ee32 100644
--- a/drivers/mtd/maps/pci.c
+++ b/drivers/mtd/maps/pci.c
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
diff --git a/drivers/mtd/maps/plat-ram.c b/drivers/mtd/maps/plat-ram.c
index e751e05fcc65..104576b5be34 100644
--- a/drivers/mtd/maps/plat-ram.c
+++ b/drivers/mtd/maps/plat-ram.c
@@ -29,6 +29,8 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
 
 #include <linux/mtd/mtd.h>
diff --git a/drivers/mtd/maps/sa1100-flash.c b/drivers/mtd/maps/sa1100-flash.c
index 66b4c2780adc..c8d0da19d897 100644
--- a/drivers/mtd/maps/sa1100-flash.c
+++ b/drivers/mtd/maps/sa1100-flash.c
@@ -130,20 +130,21 @@ struct sa_subdev_info {
         char name[16];
         struct map_info map;
         struct mtd_info *mtd;
-        struct flash_platform_data *data;
+        struct flash_platform_data *plat;
 };
 
 struct sa_info {
         struct mtd_partition    *parts;
         struct mtd_info         *mtd;
         int                     num_subdev;
+        unsigned int            nr_parts;
         struct sa_subdev_info   subdev[0];
 };
 
 static void sa1100_set_vpp(struct map_info *map, int on)
 {
         struct sa_subdev_info *subdev = container_of(map, struct sa_subdev_info, map);
-        subdev->data->set_vpp(on);
+        subdev->plat->set_vpp(on);
 }
 
 static void sa1100_destroy_subdev(struct sa_subdev_info *subdev)
@@ -187,7 +188,7 @@ static int sa1100_probe_subdev(struct sa_subdev_info *subdev, struct resource *r
                 goto out;
         }
 
-        if (subdev->data->set_vpp)
+        if (subdev->plat->set_vpp)
                 subdev->map.set_vpp = sa1100_set_vpp;
 
         subdev->map.phys = phys;
@@ -204,7 +205,7 @@ static int sa1100_probe_subdev(struct sa_subdev_info *subdev, struct resource *r
          * Now let's probe for the actual flash.  Do it here since
          * specific machine settings might have been set above.
          */
-        subdev->mtd = do_map_probe(subdev->data->map_name, &subdev->map);
+        subdev->mtd = do_map_probe(subdev->plat->map_name, &subdev->map);
         if (subdev->mtd == NULL) {
                 ret = -ENXIO;
                 goto err;
@@ -223,13 +224,17 @@ static int sa1100_probe_subdev(struct sa_subdev_info *subdev, struct resource *r
         return ret;
 }
 
-static void sa1100_destroy(struct sa_info *info)
+static void sa1100_destroy(struct sa_info *info, struct flash_platform_data *plat)
 {
         int i;
 
         if (info->mtd) {
-                del_mtd_partitions(info->mtd);
-
+                if (info->nr_parts == 0)
+                        del_mtd_device(info->mtd);
+#ifdef CONFIG_MTD_PARTITIONS
+                else
+                        del_mtd_partitions(info->mtd);
+#endif
 #ifdef CONFIG_MTD_CONCAT
                 if (info->mtd != info->subdev[0].mtd)
                         mtd_concat_destroy(info->mtd);
@@ -242,10 +247,13 @@ static void sa1100_destroy(struct sa_info *info)
         for (i = info->num_subdev - 1; i >= 0; i--)
                 sa1100_destroy_subdev(&info->subdev[i]);
         kfree(info);
+
+        if (plat->exit)
+                plat->exit();
 }
 
 static struct sa_info *__init
-sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *flash)
+sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *plat)
 {
         struct sa_info *info;
         int nr, size, i, ret = 0;
@@ -275,6 +283,12 @@ sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *flash
 
         memset(info, 0, size);
 
+        if (plat->init) {
+                ret = plat->init();
+                if (ret)
+                        goto err;
+        }
+
         /*
          * Claim and then map the memory regions.
          */
@@ -287,8 +301,8 @@ sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *flash
                         break;
 
                 subdev->map.name = subdev->name;
-                sprintf(subdev->name, "sa1100-%d", i);
-                subdev->data = flash;
+                sprintf(subdev->name, "%s-%d", plat->name, i);
+                subdev->plat = plat;
 
                 ret = sa1100_probe_subdev(subdev, res);
                 if (ret)
@@ -309,7 +323,7 @@ sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *flash
          * otherwise fail.  Either way, it'll be called "sa1100".
          */
         if (info->num_subdev == 1) {
-                strcpy(info->subdev[0].name, "sa1100");
+                strcpy(info->subdev[0].name, plat->name);
                 info->mtd = info->subdev[0].mtd;
                 ret = 0;
         } else if (info->num_subdev > 1) {
@@ -322,7 +336,7 @@ sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *flash
                         cdev[i] = info->subdev[i].mtd;
 
                 info->mtd = mtd_concat_create(cdev, info->num_subdev,
-                                              "sa1100");
+                                              plat->name);
                 if (info->mtd == NULL)
                         ret = -ENXIO;
 #else
@@ -336,7 +350,7 @@ sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *flash
                 return info;
 
  err:
-        sa1100_destroy(info);
+        sa1100_destroy(info, plat);
  out:
         return ERR_PTR(ret);
 }
@@ -346,16 +360,16 @@ static const char *part_probes[] = { "cmdlinepart", "RedBoot", NULL };
 static int __init sa1100_mtd_probe(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
-        struct flash_platform_data *flash = pdev->dev.platform_data;
+        struct flash_platform_data *plat = pdev->dev.platform_data;
         struct mtd_partition *parts;
         const char *part_type = NULL;
         struct sa_info *info;
         int err, nr_parts = 0;
 
-        if (!flash)
+        if (!plat)
                 return -ENODEV;
 
-        info = sa1100_setup_mtd(pdev, flash);
+        info = sa1100_setup_mtd(pdev, plat);
         if (IS_ERR(info)) {
                 err = PTR_ERR(info);
                 goto out;
@@ -372,8 +386,8 @@ static int __init sa1100_mtd_probe(struct device *dev)
         } else
 #endif
         {
-                parts = flash->parts;
-                nr_parts = flash->nr_parts;
+                parts = plat->parts;
+                nr_parts = plat->nr_parts;
                 part_type = "static";
         }
 
@@ -387,6 +401,8 @@ static int __init sa1100_mtd_probe(struct device *dev)
                 add_mtd_partitions(info->mtd, parts, nr_parts);
         }
 
+        info->nr_parts = nr_parts;
+
         dev_set_drvdata(dev, info);
         err = 0;
 
@@ -397,8 +413,11 @@ static int __init sa1100_mtd_probe(struct device *dev)
 static int __exit sa1100_mtd_remove(struct device *dev)
 {
         struct sa_info *info = dev_get_drvdata(dev);
+        struct flash_platform_data *plat = dev->platform_data;
+
         dev_set_drvdata(dev, NULL);
-        sa1100_destroy(info);
+        sa1100_destroy(info, plat);
+
         return 0;
 }
 
@@ -421,9 +440,17 @@ static int sa1100_mtd_resume(struct device *dev)
                 info->mtd->resume(info->mtd);
         return 0;
 }
+
+static void sa1100_mtd_shutdown(struct device *dev)
+{
+        struct sa_info *info = dev_get_drvdata(dev);
+        if (info && info->mtd->suspend(info->mtd) == 0)
+                info->mtd->resume(info->mtd);
+}
 #else
 #define sa1100_mtd_suspend NULL
 #define sa1100_mtd_resume  NULL
+#define sa1100_mtd_shutdown NULL
 #endif
 
 static struct device_driver sa1100_mtd_driver = {
@@ -433,6 +460,7 @@ static struct device_driver sa1100_mtd_driver = {
         .remove         = __exit_p(sa1100_mtd_remove),
         .suspend        = sa1100_mtd_suspend,
         .resume         = sa1100_mtd_resume,
+        .shutdown       = sa1100_mtd_shutdown,
 };
 
 static int __init sa1100_mtd_init(void)
diff --git a/drivers/mtd/maps/tqm8xxl.c b/drivers/mtd/maps/tqm8xxl.c
index 995e9991cb8d..4e28b977f224 100644
--- a/drivers/mtd/maps/tqm8xxl.c
+++ b/drivers/mtd/maps/tqm8xxl.c
@@ -27,12 +27,14 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <asm/io.h>
+#include <linux/slab.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
 #include <linux/mtd/partitions.h>
 
+#include <asm/io.h>
+
 #define FLASH_ADDR 0x40000000
 #define FLASH_SIZE 0x00800000
 #define FLASH_BANK_MAX 4
diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index b7c32c242bc7..400dd9c89883 100644
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
+#include <linux/sched.h>        /* TASK_* */
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/blktrans.h>
 
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index c534fd5d95cb..16df1e4fb0e9 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -13,6 +13,7 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/fs.h>
+#include <linux/sched.h>        /* TASK_* */
 #include <asm/uaccess.h>
 
 #include <linux/device.h>
diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
index 8f66d093c80d..f3e65af33a9c 100644
--- a/drivers/mtd/mtdconcat.c
+++ b/drivers/mtd/mtdconcat.c
@@ -14,7 +14,7 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
-
+#include <linux/sched.h>        /* TASK_* */
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/concat.h>
 
diff --git a/drivers/mtd/nand/s3c2410.c b/drivers/mtd/nand/s3c2410.c
index bf2325df80c7..2df5e47d1f5c 100644
--- a/drivers/mtd/nand/s3c2410.c
+++ b/drivers/mtd/nand/s3c2410.c
@@ -51,6 +51,7 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/nand.h>
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index fee8c5cf1f3a..6d4f9ceb0a32 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1163,38 +1163,74 @@ config IBMVETH
           be called ibmveth.
 
 config IBM_EMAC
-        bool "IBM PPC4xx EMAC driver support"
+        tristate "PowerPC 4xx on-chip Ethernet support"
         depends on 4xx
-        select CRC32
-        ---help---
-          This driver supports the IBM PPC4xx EMAC family of on-chip
-          Ethernet controllers.
-
-config IBM_EMAC_ERRMSG
-        bool "Verbose error messages"
-        depends on IBM_EMAC && BROKEN
+        help
+          This driver supports the PowerPC 4xx EMAC family of on-chip
+          Ethernet controllers.
 
 config IBM_EMAC_RXB
         int "Number of receive buffers"
         depends on IBM_EMAC
-        default "128" if IBM_EMAC4
-        default "64"
+        default "128"
 
 config IBM_EMAC_TXB
         int "Number of transmit buffers"
         depends on IBM_EMAC
-        default "128" if IBM_EMAC4
-        default "8"
+        default "64"
+
+config IBM_EMAC_POLL_WEIGHT
+        int "MAL NAPI polling weight"
+        depends on IBM_EMAC
+        default "32"
 
-config IBM_EMAC_FGAP
-        int "Frame gap"
+config IBM_EMAC_RX_COPY_THRESHOLD
+        int "RX skb copy threshold (bytes)"
         depends on IBM_EMAC
-        default "8"
+        default "256"
 
-config IBM_EMAC_SKBRES
-        int "Skb reserve amount"
+config IBM_EMAC_RX_SKB_HEADROOM
+        int "Additional RX skb headroom (bytes)"
         depends on IBM_EMAC
         default "0"
+        help
+          Additional receive skb headroom. Note, that driver
+          will always reserve at least 2 bytes to make IP header
+          aligned, so usualy there is no need to add any additional
+          headroom.
+          
+          If unsure, set to 0.
+
+config IBM_EMAC_PHY_RX_CLK_FIX
+        bool "PHY Rx clock workaround"
+        depends on IBM_EMAC && (405EP || 440GX || 440EP)
+        help
+          Enable this if EMAC attached to a PHY which doesn't generate
+          RX clock if there is no link, if this is the case, you will 
+          see "TX disable timeout" or "RX disable timeout" in the system
+          log.
+          
+          If unsure, say N.
+
+config IBM_EMAC_DEBUG
+        bool "Debugging"
+        depends on IBM_EMAC
+        default n
+
+config IBM_EMAC_ZMII
+        bool
+        depends on IBM_EMAC && (NP405H || NP405L || 44x)
+        default y
+
+config IBM_EMAC_RGMII
+        bool
+        depends on IBM_EMAC && 440GX
+        default y
+                
+config IBM_EMAC_TAH
+        bool
+        depends on IBM_EMAC && 440GX
+        default y
 
 config NET_PCI
         bool "EISA, VLB, PCI and on board controllers"
@@ -1775,6 +1811,7 @@ config NE_H8300
           controller on the Renesas H8/300 processor.
 
 source "drivers/net/fec_8xx/Kconfig"
+source "drivers/net/fs_enet/Kconfig"
 
 endmenu
 
@@ -2201,8 +2238,8 @@ config S2IO
         depends on PCI
         ---help---
           This driver supports the 10Gbe XFrame NIC of S2IO. 
-          For help regarding driver compilation, installation and 
-          tuning please look into ~/drivers/net/s2io/README.txt.
+          More specific information on configuring the driver is in 
+          <file:Documentation/networking/s2io.txt>.
 
 config S2IO_NAPI
         bool "Use Rx Polling (NAPI) (EXPERIMENTAL)"
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 1a84e0435f64..7c313cb341b8 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -203,3 +203,6 @@ obj-$(CONFIG_IRDA) += irda/
 obj-$(CONFIG_ETRAX_ETHERNET) += cris/
 
 obj-$(CONFIG_NETCONSOLE) += netconsole.o
+
+obj-$(CONFIG_FS_ENET) += fs_enet/
+
diff --git a/drivers/net/acenic.c b/drivers/net/acenic.c
index dbecc6bf7851..b8953de5664a 100644
--- a/drivers/net/acenic.c
+++ b/drivers/net/acenic.c
@@ -871,10 +871,8 @@ static void ace_init_cleanup(struct net_device *dev)
         if (ap->info)
                 pci_free_consistent(ap->pdev, sizeof(struct ace_info),
                                     ap->info, ap->info_dma);
-        if (ap->skb)
-                kfree(ap->skb);
-        if (ap->trace_buf)
-                kfree(ap->trace_buf);
+        kfree(ap->skb);
+        kfree(ap->trace_buf);
 
         if (dev->irq)
                 free_irq(dev->irq, dev);
diff --git a/drivers/net/amd8111e.c b/drivers/net/amd8111e.c
index d9ba8be72af8..d9ba8be72af8 100755..100644
--- a/drivers/net/amd8111e.c
+++ b/drivers/net/amd8111e.c
diff --git a/drivers/net/amd8111e.h b/drivers/net/amd8111e.h
index cfe3a4298822..cfe3a4298822 100755..100644
--- a/drivers/net/amd8111e.h
+++ b/drivers/net/amd8111e.h
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index 78506911d656..332e9953c55c 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -1606,8 +1606,7 @@ err_out:
         /* here we should have a valid dev plus aup-> register addresses
          * so we can reset the mac properly.*/
         reset_mac(dev);
-        if (aup->mii)
-                kfree(aup->mii);
+        kfree(aup->mii);
         for (i = 0; i < NUM_RX_DMA; i++) {
                 if (aup->rx_db_inuse[i])
                         ReleaseDB(aup, aup->rx_db_inuse[i]);
@@ -1806,8 +1805,7 @@ static void __exit au1000_cleanup_module(void)
                 if (dev) {
                         aup = (struct au1000_private *) dev->priv;
                         unregister_netdev(dev);
-                        if (aup->mii)
-                                kfree(aup->mii);
+                        kfree(aup->mii);
                         for (j = 0; j < NUM_RX_DMA; j++) {
                                 if (aup->rx_db_inuse[j])
                                         ReleaseDB(aup, aup->rx_db_inuse[j]);
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 282ebd15f011..0ee3e27969c6 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -19,6 +19,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/version.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -1130,14 +1131,10 @@ static void b44_init_rings(struct b44 *bp)
  */
 static void b44_free_consistent(struct b44 *bp)
 {
-        if (bp->rx_buffers) {
-                kfree(bp->rx_buffers);
-                bp->rx_buffers = NULL;
-        }
-        if (bp->tx_buffers) {
-                kfree(bp->tx_buffers);
-                bp->tx_buffers = NULL;
-        }
+        kfree(bp->rx_buffers);
+        bp->rx_buffers = NULL;
+        kfree(bp->tx_buffers);
+        bp->tx_buffers = NULL;
         if (bp->rx_ring) {
                 if (bp->flags & B44_FLAG_RX_RING_HACK) {
                         dma_unmap_single(&bp->pdev->dev, bp->rx_ring_dma,
@@ -1619,14 +1616,14 @@ static int b44_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 
         cmd->advertising = 0;
         if (bp->flags & B44_FLAG_ADV_10HALF)
-                cmd->advertising |= ADVERTISE_10HALF;
+                cmd->advertising |= ADVERTISED_10baseT_Half;
         if (bp->flags & B44_FLAG_ADV_10FULL)
-                cmd->advertising |= ADVERTISE_10FULL;
+                cmd->advertising |= ADVERTISED_10baseT_Full;
         if (bp->flags & B44_FLAG_ADV_100HALF)
-                cmd->advertising |= ADVERTISE_100HALF;
+                cmd->advertising |= ADVERTISED_100baseT_Half;
         if (bp->flags & B44_FLAG_ADV_100FULL)
-                cmd->advertising |= ADVERTISE_100FULL;
-        cmd->advertising |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
+                cmd->advertising |= ADVERTISED_100baseT_Full;
+        cmd->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
         cmd->speed = (bp->flags & B44_FLAG_100_BASE_T) ?
                 SPEED_100 : SPEED_10;
         cmd->duplex = (bp->flags & B44_FLAG_FULL_DUPLEX) ?
@@ -2044,6 +2041,8 @@ static int b44_suspend(struct pci_dev *pdev, pm_message_t state)
         b44_free_rings(bp);
 
         spin_unlock_irq(&bp->lock);
+
+        free_irq(dev->irq, dev);
         pci_disable_device(pdev);
         return 0;
 }
@@ -2060,6 +2059,9 @@ static int b44_resume(struct pci_dev *pdev)
         if (!netif_running(dev))
                 return 0;
 
+        if (request_irq(dev->irq, b44_interrupt, SA_SHIRQ, dev->name, dev))
+                printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name);
+
         spin_lock_irq(&bp->lock);
 
         b44_init_rings(bp);
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 60dba4a1ca5c..bbca8ae8018c 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1658,6 +1658,7 @@ static struct of_device_id bmac_match[] =
         },
         {},
 };
+MODULE_DEVICE_TABLE (of, bmac_match);
 
 static struct macio_driver bmac_driver = 
 {
@@ -1689,10 +1690,8 @@ static void __exit bmac_exit(void)
 {
         macio_unregister_driver(&bmac_driver);
 
-        if (bmac_emergency_rxbuf != NULL) {
-                kfree(bmac_emergency_rxbuf);
-                bmac_emergency_rxbuf = NULL;
-        }
+        kfree(bmac_emergency_rxbuf);
+        bmac_emergency_rxbuf = NULL;
 }
 
 MODULE_AUTHOR("Randy Gobbel/Paul Mackerras");
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 3a2ace01e444..11d252318221 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -314,20 +314,16 @@ bnx2_free_mem(struct bnx2 *bp)
                                     bp->tx_desc_ring, bp->tx_desc_mapping);
                 bp->tx_desc_ring = NULL;
         }
-        if (bp->tx_buf_ring) {
-                kfree(bp->tx_buf_ring);
-                bp->tx_buf_ring = NULL;
-        }
+        kfree(bp->tx_buf_ring);
+        bp->tx_buf_ring = NULL;
         if (bp->rx_desc_ring) {
                 pci_free_consistent(bp->pdev,
                                     sizeof(struct rx_bd) * RX_DESC_CNT,
                                     bp->rx_desc_ring, bp->rx_desc_mapping);
                 bp->rx_desc_ring = NULL;
         }
-        if (bp->rx_buf_ring) {
-                kfree(bp->rx_buf_ring);
-                bp->rx_buf_ring = NULL;
-        }
+        kfree(bp->rx_buf_ring);
+        bp->rx_buf_ring = NULL;
 }
 
 static int
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index 6b9acc7f94a3..9c7feaeaa6a4 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -965,11 +965,8 @@ e1000_free_desc_rings(struct e1000_adapter *adapter)
         if(rxdr->desc)
                 pci_free_consistent(pdev, rxdr->size, rxdr->desc, rxdr->dma);
 
-        if(txdr->buffer_info)
-                kfree(txdr->buffer_info);
-        if(rxdr->buffer_info)
-                kfree(rxdr->buffer_info);
-
+        kfree(txdr->buffer_info);
+        kfree(rxdr->buffer_info);
         return;
 }
 
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 6b72f6acdd54..efbbda7cbcbf 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -191,8 +191,8 @@ static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
 static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
 static void e1000_restore_vlan(struct e1000_adapter *adapter);
 
-static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
 #ifdef CONFIG_PM
+static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
 static int e1000_resume(struct pci_dev *pdev);
 #endif
 
@@ -1149,7 +1149,8 @@ e1000_setup_tx_resources(struct e1000_adapter *adapter,
         int size;
 
         size = sizeof(struct e1000_buffer) * txdr->count;
-        txdr->buffer_info = vmalloc(size);
+
+        txdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
         if(!txdr->buffer_info) {
                 DPRINTK(PROBE, ERR,
                 "Unable to allocate memory for the transmit descriptor ring\n");
@@ -1366,7 +1367,7 @@ e1000_setup_rx_resources(struct e1000_adapter *adapter,
         int size, desc_len;
 
         size = sizeof(struct e1000_buffer) * rxdr->count;
-        rxdr->buffer_info = vmalloc(size);
+        rxdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
         if (!rxdr->buffer_info) {
                 DPRINTK(PROBE, ERR,
                 "Unable to allocate memory for the receive descriptor ring\n");
@@ -4193,6 +4194,7 @@ e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
         return 0;
 }
 
+#ifdef CONFIG_PM
 static int
 e1000_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -4289,7 +4291,6 @@ e1000_suspend(struct pci_dev *pdev, pm_message_t state)
         return 0;
 }
 
-#ifdef CONFIG_PM
 static int
 e1000_resume(struct pci_dev *pdev)
 {
diff --git a/drivers/net/eepro.c b/drivers/net/eepro.c
index dcb3028bb60f..a806dfe54d23 100644
--- a/drivers/net/eepro.c
+++ b/drivers/net/eepro.c
@@ -552,8 +552,7 @@ static int __init do_eepro_probe(struct net_device *dev)
         {
                 unsigned short int WS[32]=WakeupSeq;
 
-                if (check_region(WakeupPort, 2)==0) {
-
+                if (request_region(WakeupPort, 2, "eepro wakeup")) {
                         if (net_debug>5)
                                 printk(KERN_DEBUG "Waking UP\n");
 
@@ -563,7 +562,10 @@ static int __init do_eepro_probe(struct net_device *dev)
                                 outb_p(WS[i],WakeupPort);
                                 if (net_debug>5) printk(KERN_DEBUG ": %#x ",WS[i]);
                         }
-                } else printk(KERN_WARNING "Checkregion Failed!\n");
+
+                        release_region(WakeupPort, 2);
+                } else
+                        printk(KERN_WARNING "PnP wakeup region busy!\n");
         }
 #endif
 
@@ -705,7 +707,7 @@ static void __init eepro_print_info (struct net_device *dev)
                                         dev->name, (unsigned)dev->base_addr);
                         break;
                 case LAN595FX:
-                        printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,", 
+                        printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,",
                                         dev->name, (unsigned)dev->base_addr);
                         break;
                 case LAN595TX:
@@ -713,7 +715,7 @@ static void __init eepro_print_info (struct net_device *dev)
                                         dev->name, (unsigned)dev->base_addr);
                         break;
                 case LAN595:
-                        printk("%s: Intel 82595-based lan card at %#x,", 
+                        printk("%s: Intel 82595-based lan card at %#x,",
                                         dev->name, (unsigned)dev->base_addr);
         }
 
@@ -726,7 +728,7 @@ static void __init eepro_print_info (struct net_device *dev)
 
         if (dev->irq > 2)
                 printk(", IRQ %d, %s.\n", dev->irq, ifmap[dev->if_port]);
-        else 
+        else
                 printk(", %s.\n", ifmap[dev->if_port]);
 
         if (net_debug > 3) {
@@ -756,7 +758,7 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
         int err;
 
         /* Grab the region so we can find another board if autoIRQ fails. */
-        if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) { 
+        if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) {
                 if (!autoprobe)
                         printk(KERN_WARNING "EEPRO: io-port 0x%04x in use \n",
                                 ioaddr);
@@ -838,15 +840,15 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
                 /* Mask off INT number */
                 int count = lp->word[1] & 7;
                 unsigned irqMask = lp->word[7];
- 
+
                 while (count--)
                         irqMask &= irqMask - 1;
- 
+
                 count = ffs(irqMask);
- 
+
                 if (count)
                         dev->irq = count - 1;
- 
+
                 if (dev->irq < 2) {
                         printk(KERN_ERR " Duh! illegal interrupt vector stored in EEPROM.\n");
                         goto exit;
@@ -854,7 +856,7 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
                         dev->irq = 9;
                 }
         }
- 
+
         dev->open               = eepro_open;
         dev->stop               = eepro_close;
         dev->hard_start_xmit    = eepro_send_packet;
@@ -863,7 +865,7 @@ static int __init eepro_probe1(struct net_device *dev, int autoprobe)
         dev->tx_timeout         = eepro_tx_timeout;
         dev->watchdog_timeo     = TX_TIMEOUT;
         dev->ethtool_ops        = &eepro_ethtool_ops;
- 
+
         /* print boot time info */
         eepro_print_info(dev);
 
@@ -1047,8 +1049,8 @@ static int eepro_open(struct net_device *dev)
 
 
         /* Initialize the RCV and XMT upper and lower limits */
-        outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG); 
-        outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG); 
+        outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG);
+        outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG);
         outb(lp->xmt_lower_limit >> 8, ioaddr + lp->xmt_lower_limit_reg);
         outb(lp->xmt_upper_limit >> 8, ioaddr + lp->xmt_upper_limit_reg);
 
@@ -1065,12 +1067,12 @@ static int eepro_open(struct net_device *dev)
         eepro_clear_int(ioaddr);
 
         /* Initialize RCV */
-        outw(lp->rcv_lower_limit, ioaddr + RCV_BAR); 
+        outw(lp->rcv_lower_limit, ioaddr + RCV_BAR);
         lp->rx_start = lp->rcv_lower_limit;
-        outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP); 
+        outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP);
 
         /* Initialize XMT */
-        outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar); 
+        outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar);
         lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
         lp->tx_last = 0;
 
@@ -1411,7 +1413,7 @@ set_multicast_list(struct net_device *dev)
                                 outb(0x08, ioaddr + STATUS_REG);
 
                                 if (i & 0x20) { /* command ABORTed */
-                                        printk(KERN_NOTICE "%s: multicast setup failed.\n", 
+                                        printk(KERN_NOTICE "%s: multicast setup failed.\n",
                                                 dev->name);
                                         break;
                                 } else if ((i & 0x0f) == 0x03)  { /* MC-Done */
@@ -1512,7 +1514,7 @@ hardware_send_packet(struct net_device *dev, void *buf, short length)
                 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
 
         if (end >= lp->xmt_upper_limit + 2) { /* the transmit buffer is wrapped around */
-                if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {   
+                if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {
                                 /* Arrrr!!!, must keep the xmt header together,
                                 several days were lost to chase this one down. */
                         last = lp->xmt_lower_limit;
@@ -1643,7 +1645,7 @@ eepro_rx(struct net_device *dev)
                         else if (rcv_status & 0x0800)
                                 lp->stats.rx_crc_errors++;
 
-                        printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n", 
+                        printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n",
                                 dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
                 }
 
@@ -1674,10 +1676,10 @@ eepro_transmit_interrupt(struct net_device *dev)
 {
         struct eepro_local *lp = netdev_priv(dev);
         short ioaddr = dev->base_addr;
-        short boguscount = 25; 
+        short boguscount = 25;
         short xmt_status;
 
-        while ((lp->tx_start != lp->tx_end) && boguscount--) { 
+        while ((lp->tx_start != lp->tx_end) && boguscount--) {
 
                 outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
                 xmt_status = inw(ioaddr+IO_PORT);
@@ -1723,7 +1725,7 @@ static int eepro_ethtool_get_settings(struct net_device *dev,
 {
         struct eepro_local      *lp = (struct eepro_local *)dev->priv;
 
-        cmd->supported =        SUPPORTED_10baseT_Half | 
+        cmd->supported =        SUPPORTED_10baseT_Half |
                                 SUPPORTED_10baseT_Full |
                                 SUPPORTED_Autoneg;
         cmd->advertising =      ADVERTISED_10baseT_Half |
@@ -1797,10 +1799,9 @@ MODULE_AUTHOR("Pascal Dupuis and others");
 MODULE_DESCRIPTION("Intel i82595 ISA EtherExpressPro10/10+ driver");
 MODULE_LICENSE("GPL");
 
-static int num_params;
-module_param_array(io, int, &num_params, 0);
-module_param_array(irq, int, &num_params, 0);
-module_param_array(mem, int, &num_params, 0);
+module_param_array(io, int, NULL, 0);
+module_param_array(irq, int, NULL, 0);
+module_param_array(mem, int, NULL, 0);
 module_param(autodetect, int, 0);
 MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)");
 MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)");
diff --git a/drivers/net/fs_enet/Kconfig b/drivers/net/fs_enet/Kconfig
new file mode 100644
index 000000000000..6aaee67dd4b7
--- /dev/null
+++ b/drivers/net/fs_enet/Kconfig
@@ -0,0 +1,20 @@
+config FS_ENET
+       tristate "Freescale Ethernet Driver"
+       depends on NET_ETHERNET && (CPM1 || CPM2)
+       select MII
+
+config FS_ENET_HAS_SCC
+        bool "Chip has an SCC usable for ethernet"
+        depends on FS_ENET && (CPM1 || CPM2)
+        default y
+
+config FS_ENET_HAS_FCC
+        bool "Chip has an FCC usable for ethernet"
+        depends on FS_ENET && CPM2
+        default y
+
+config FS_ENET_HAS_FEC
+        bool "Chip has an FEC usable for ethernet"
+        depends on FS_ENET && CPM1
+        default y
+
diff --git a/drivers/net/fs_enet/Makefile b/drivers/net/fs_enet/Makefile
new file mode 100644
index 000000000000..d6dd3f2fb43e
--- /dev/null
+++ b/drivers/net/fs_enet/Makefile
@@ -0,0 +1,10 @@
+#
+# Makefile for the Freescale Ethernet controllers
+#
+
+obj-$(CONFIG_FS_ENET) += fs_enet.o
+
+obj-$(CONFIG_8xx) += mac-fec.o mac-scc.o
+obj-$(CONFIG_8260) += mac-fcc.o
+
+fs_enet-objs := fs_enet-main.o fs_enet-mii.o mii-bitbang.o mii-fixed.o
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
new file mode 100644
index 000000000000..44fac7373289
--- /dev/null
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -0,0 +1,1226 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
+ * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <linux/vmalloc.h>
+#include <asm/pgtable.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+static char version[] __devinitdata =
+    DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")" "\n";
+
+MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
+MODULE_DESCRIPTION("Freescale Ethernet Driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_MODULE_VERSION);
+
+MODULE_PARM(fs_enet_debug, "i");
+MODULE_PARM_DESC(fs_enet_debug,
+                 "Freescale bitmapped debugging message enable value");
+
+int fs_enet_debug = -1;         /* -1 == use FS_ENET_DEF_MSG_ENABLE as value */
+
+static void fs_set_multicast_list(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        (*fep->ops->set_multicast_list)(dev);
+}
+
+/* NAPI receive function */
+static int fs_enet_rx_napi(struct net_device *dev, int *budget)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        cbd_t *bdp;
+        struct sk_buff *skb, *skbn, *skbt;
+        int received = 0;
+        u16 pkt_len, sc;
+        int curidx;
+        int rx_work_limit = 0;  /* pacify gcc */
+
+        rx_work_limit = min(dev->quota, *budget);
+
+        if (!netif_running(dev))
+                return 0;
+
+        /*
+         * First, grab all of the stats for the incoming packet.
+         * These get messed up if we get called due to a busy condition.
+         */
+        bdp = fep->cur_rx;
+
+        /* clear RX status bits for napi*/
+        (*fep->ops->napi_clear_rx_event)(dev);
+
+        while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
+
+                curidx = bdp - fep->rx_bd_base;
+
+                /*
+                 * Since we have allocated space to hold a complete frame,
+                 * the last indicator should be set.
+                 */
+                if ((sc & BD_ENET_RX_LAST) == 0)
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s rcv is not +last\n",
+                               dev->name);
+
+                /*
+                 * Check for errors. 
+                 */
+                if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
+                          BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
+                        fep->stats.rx_errors++;
+                        /* Frame too long or too short. */
+                        if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
+                                fep->stats.rx_length_errors++;
+                        /* Frame alignment */
+                        if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
+                                fep->stats.rx_frame_errors++;
+                        /* CRC Error */
+                        if (sc & BD_ENET_RX_CR)
+                                fep->stats.rx_crc_errors++;
+                        /* FIFO overrun */
+                        if (sc & BD_ENET_RX_OV)
+                                fep->stats.rx_crc_errors++;
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        skbn = skb;
+
+                } else {
+
+                        /* napi, got packet but no quota */
+                        if (--rx_work_limit < 0)
+                                break;
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        /*
+                         * Process the incoming frame.
+                         */
+                        fep->stats.rx_packets++;
+                        pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
+                        fep->stats.rx_bytes += pkt_len + 4;
+
+                        if (pkt_len <= fpi->rx_copybreak) {
+                                /* +2 to make IP header L1 cache aligned */
+                                skbn = dev_alloc_skb(pkt_len + 2);
+                                if (skbn != NULL) {
+                                        skb_reserve(skbn, 2);   /* align IP header */
+                                        memcpy(skbn->data, skb->data, pkt_len);
+                                        /* swap */
+                                        skbt = skb;
+                                        skb = skbn;
+                                        skbn = skbt;
+                                }
+                        } else
+                                skbn = dev_alloc_skb(ENET_RX_FRSIZE);
+
+                        if (skbn != NULL) {
+                                skb->dev = dev;
+                                skb_put(skb, pkt_len);  /* Make room */
+                                skb->protocol = eth_type_trans(skb, dev);
+                                received++;
+                                netif_receive_skb(skb);
+                        } else {
+                                printk(KERN_WARNING DRV_MODULE_NAME
+                                       ": %s Memory squeeze, dropping packet.\n",
+                                       dev->name);
+                                fep->stats.rx_dropped++;
+                                skbn = skb;
+                        }
+                }
+
+                fep->rx_skbuff[curidx] = skbn;
+                CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
+                             L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                             DMA_FROM_DEVICE));
+                CBDW_DATLEN(bdp, 0);
+                CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
+
+                /*
+                 * Update BD pointer to next entry. 
+                 */
+                if ((sc & BD_ENET_RX_WRAP) == 0)
+                        bdp++;
+                else
+                        bdp = fep->rx_bd_base;
+
+                (*fep->ops->rx_bd_done)(dev);
+        }
+
+        fep->cur_rx = bdp;
+
+        dev->quota -= received;
+        *budget -= received;
+
+        if (rx_work_limit < 0)
+                return 1;       /* not done */
+
+        /* done */
+        netif_rx_complete(dev);
+
+        (*fep->ops->napi_enable_rx)(dev);
+
+        return 0;
+}
+
+/* non NAPI receive function */
+static int fs_enet_rx_non_napi(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        cbd_t *bdp;
+        struct sk_buff *skb, *skbn, *skbt;
+        int received = 0;
+        u16 pkt_len, sc;
+        int curidx;
+        /*
+         * First, grab all of the stats for the incoming packet.
+         * These get messed up if we get called due to a busy condition.
+         */
+        bdp = fep->cur_rx;
+
+        while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
+
+                curidx = bdp - fep->rx_bd_base;
+
+                /*
+                 * Since we have allocated space to hold a complete frame,
+                 * the last indicator should be set.
+                 */
+                if ((sc & BD_ENET_RX_LAST) == 0)
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s rcv is not +last\n",
+                               dev->name);
+
+                /*
+                 * Check for errors. 
+                 */
+                if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
+                          BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
+                        fep->stats.rx_errors++;
+                        /* Frame too long or too short. */
+                        if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
+                                fep->stats.rx_length_errors++;
+                        /* Frame alignment */
+                        if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
+                                fep->stats.rx_frame_errors++;
+                        /* CRC Error */
+                        if (sc & BD_ENET_RX_CR)
+                                fep->stats.rx_crc_errors++;
+                        /* FIFO overrun */
+                        if (sc & BD_ENET_RX_OV)
+                                fep->stats.rx_crc_errors++;
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        skbn = skb;
+
+                } else {
+
+                        skb = fep->rx_skbuff[curidx];
+
+                        dma_unmap_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE);
+
+                        /*
+                         * Process the incoming frame.
+                         */
+                        fep->stats.rx_packets++;
+                        pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
+                        fep->stats.rx_bytes += pkt_len + 4;
+
+                        if (pkt_len <= fpi->rx_copybreak) {
+                                /* +2 to make IP header L1 cache aligned */
+                                skbn = dev_alloc_skb(pkt_len + 2);
+                                if (skbn != NULL) {
+                                        skb_reserve(skbn, 2);   /* align IP header */
+                                        memcpy(skbn->data, skb->data, pkt_len);
+                                        /* swap */
+                                        skbt = skb;
+                                        skb = skbn;
+                                        skbn = skbt;
+                                }
+                        } else
+                                skbn = dev_alloc_skb(ENET_RX_FRSIZE);
+
+                        if (skbn != NULL) {
+                                skb->dev = dev;
+                                skb_put(skb, pkt_len);  /* Make room */
+                                skb->protocol = eth_type_trans(skb, dev);
+                                received++;
+                                netif_rx(skb);
+                        } else {
+                                printk(KERN_WARNING DRV_MODULE_NAME
+                                       ": %s Memory squeeze, dropping packet.\n",
+                                       dev->name);
+                                fep->stats.rx_dropped++;
+                                skbn = skb;
+                        }
+                }
+
+                fep->rx_skbuff[curidx] = skbn;
+                CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
+                             L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                             DMA_FROM_DEVICE));
+                CBDW_DATLEN(bdp, 0);
+                CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
+
+                /*
+                 * Update BD pointer to next entry. 
+                 */
+                if ((sc & BD_ENET_RX_WRAP) == 0)
+                        bdp++;
+                else
+                        bdp = fep->rx_bd_base;
+
+                (*fep->ops->rx_bd_done)(dev);
+        }
+
+        fep->cur_rx = bdp;
+
+        return 0;
+}
+
+static void fs_enet_tx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        cbd_t *bdp;
+        struct sk_buff *skb;
+        int dirtyidx, do_wake, do_restart;
+        u16 sc;
+
+        spin_lock(&fep->lock);
+        bdp = fep->dirty_tx;
+
+        do_wake = do_restart = 0;
+        while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0) {
+
+                dirtyidx = bdp - fep->tx_bd_base;
+
+                if (fep->tx_free == fep->tx_ring)
+                        break;
+
+                skb = fep->tx_skbuff[dirtyidx];
+
+                /*
+                 * Check for errors. 
+                 */
+                if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
+                          BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
+
+                        if (sc & BD_ENET_TX_HB) /* No heartbeat */
+                                fep->stats.tx_heartbeat_errors++;
+                        if (sc & BD_ENET_TX_LC) /* Late collision */
+                                fep->stats.tx_window_errors++;
+                        if (sc & BD_ENET_TX_RL) /* Retrans limit */
+                                fep->stats.tx_aborted_errors++;
+                        if (sc & BD_ENET_TX_UN) /* Underrun */
+                                fep->stats.tx_fifo_errors++;
+                        if (sc & BD_ENET_TX_CSL)        /* Carrier lost */
+                                fep->stats.tx_carrier_errors++;
+
+                        if (sc & (BD_ENET_TX_LC | BD_ENET_TX_RL | BD_ENET_TX_UN)) {
+                                fep->stats.tx_errors++;
+                                do_restart = 1;
+                        }
+                } else
+                        fep->stats.tx_packets++;
+
+                if (sc & BD_ENET_TX_READY)
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s HEY! Enet xmit interrupt and TX_READY.\n",
+                               dev->name);
+
+                /*
+                 * Deferred means some collisions occurred during transmit,
+                 * but we eventually sent the packet OK.
+                 */
+                if (sc & BD_ENET_TX_DEF)
+                        fep->stats.collisions++;
+
+                /* unmap */
+                dma_unmap_single(fep->dev, skb->data, skb->len, DMA_TO_DEVICE);
+
+                /*
+                 * Free the sk buffer associated with this last transmit. 
+                 */
+                dev_kfree_skb_irq(skb);
+                fep->tx_skbuff[dirtyidx] = NULL;
+
+                /*
+                 * Update pointer to next buffer descriptor to be transmitted. 
+                 */
+                if ((sc & BD_ENET_TX_WRAP) == 0)
+                        bdp++;
+                else
+                        bdp = fep->tx_bd_base;
+
+                /*
+                 * Since we have freed up a buffer, the ring is no longer
+                 * full.
+                 */
+                if (!fep->tx_free++)
+                        do_wake = 1;
+        }
+
+        fep->dirty_tx = bdp;
+
+        if (do_restart)
+                (*fep->ops->tx_restart)(dev);
+
+        spin_unlock(&fep->lock);
+
+        if (do_wake)
+                netif_wake_queue(dev);
+}
+
+/*
+ * The interrupt handler.
+ * This is called from the MPC core interrupt.
+ */
+static irqreturn_t
+fs_enet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct fs_enet_private *fep;
+        const struct fs_platform_info *fpi;
+        u32 int_events;
+        u32 int_clr_events;
+        int nr, napi_ok;
+        int handled;
+
+        fep = netdev_priv(dev);
+        fpi = fep->fpi;
+
+        nr = 0;
+        while ((int_events = (*fep->ops->get_int_events)(dev)) != 0) {
+
+                nr++;
+
+                int_clr_events = int_events;
+                if (fpi->use_napi)
+                        int_clr_events &= ~fep->ev_napi_rx;
+
+                (*fep->ops->clear_int_events)(dev, int_clr_events);
+
+                if (int_events & fep->ev_err)
+                        (*fep->ops->ev_error)(dev, int_events);
+
+                if (int_events & fep->ev_rx) {
+                        if (!fpi->use_napi)
+                                fs_enet_rx_non_napi(dev);
+                        else {
+                                napi_ok = netif_rx_schedule_prep(dev);
+
+                                (*fep->ops->napi_disable_rx)(dev);
+                                (*fep->ops->clear_int_events)(dev, fep->ev_napi_rx);
+
+                                /* NOTE: it is possible for FCCs in NAPI mode    */
+                                /* to submit a spurious interrupt while in poll  */
+                                if (napi_ok)
+                                        __netif_rx_schedule(dev);
+                        }
+                }
+
+                if (int_events & fep->ev_tx)
+                        fs_enet_tx(dev);
+        }
+
+        handled = nr > 0;
+        return IRQ_RETVAL(handled);
+}
+
+void fs_init_bds(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        cbd_t *bdp;
+        struct sk_buff *skb;
+        int i;
+
+        fs_cleanup_bds(dev);
+
+        fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
+        fep->tx_free = fep->tx_ring;
+        fep->cur_rx = fep->rx_bd_base;
+
+        /*
+         * Initialize the receive buffer descriptors. 
+         */
+        for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
+                skb = dev_alloc_skb(ENET_RX_FRSIZE);
+                if (skb == NULL) {
+                        printk(KERN_WARNING DRV_MODULE_NAME
+                               ": %s Memory squeeze, unable to allocate skb\n",
+                               dev->name);
+                        break;
+                }
+                fep->rx_skbuff[i] = skb;
+                skb->dev = dev;
+                CBDW_BUFADDR(bdp,
+                        dma_map_single(fep->dev, skb->data,
+                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                                DMA_FROM_DEVICE));
+                CBDW_DATLEN(bdp, 0);    /* zero */
+                CBDW_SC(bdp, BD_ENET_RX_EMPTY |
+                        ((i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP));
+        }
+        /*
+         * if we failed, fillup remainder 
+         */
+        for (; i < fep->rx_ring; i++, bdp++) {
+                fep->rx_skbuff[i] = NULL;
+                CBDW_SC(bdp, (i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP);
+        }
+
+        /*
+         * ...and the same for transmit.  
+         */
+        for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
+                fep->tx_skbuff[i] = NULL;
+                CBDW_BUFADDR(bdp, 0);
+                CBDW_DATLEN(bdp, 0);
+                CBDW_SC(bdp, (i < fep->tx_ring - 1) ? 0 : BD_SC_WRAP);
+        }
+}
+
+void fs_cleanup_bds(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct sk_buff *skb;
+        int i;
+
+        /*
+         * Reset SKB transmit buffers.  
+         */
+        for (i = 0; i < fep->tx_ring; i++) {
+                if ((skb = fep->tx_skbuff[i]) == NULL)
+                        continue;
+
+                /* unmap */
+                dma_unmap_single(fep->dev, skb->data, skb->len, DMA_TO_DEVICE);
+
+                fep->tx_skbuff[i] = NULL;
+                dev_kfree_skb(skb);
+        }
+
+        /*
+         * Reset SKB receive buffers 
+         */
+        for (i = 0; i < fep->rx_ring; i++) {
+                if ((skb = fep->rx_skbuff[i]) == NULL)
+                        continue;
+
+                /* unmap */
+                dma_unmap_single(fep->dev, skb->data,
+                        L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
+                        DMA_FROM_DEVICE);
+
+                fep->rx_skbuff[i] = NULL;
+
+                dev_kfree_skb(skb);
+        }
+}
+
+/**********************************************************************************/
+
+static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        cbd_t *bdp;
+        int curidx;
+        u16 sc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fep->tx_lock, flags);
+
+        /*
+         * Fill in a Tx ring entry 
+         */
+        bdp = fep->cur_tx;
+
+        if (!fep->tx_free || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
+                netif_stop_queue(dev);
+                spin_unlock_irqrestore(&fep->tx_lock, flags);
+
+                /*
+                 * Ooops.  All transmit buffers are full.  Bail out.
+                 * This should not happen, since the tx queue should be stopped.
+                 */
+                printk(KERN_WARNING DRV_MODULE_NAME
+                       ": %s tx queue full!.\n", dev->name);
+                return NETDEV_TX_BUSY;
+        }
+
+        curidx = bdp - fep->tx_bd_base;
+        /*
+         * Clear all of the status flags. 
+         */
+        CBDC_SC(bdp, BD_ENET_TX_STATS);
+
+        /*
+         * Save skb pointer. 
+         */
+        fep->tx_skbuff[curidx] = skb;
+
+        fep->stats.tx_bytes += skb->len;
+
+        /*
+         * Push the data cache so the CPM does not get stale memory data. 
+         */
+        CBDW_BUFADDR(bdp, dma_map_single(fep->dev,
+                                skb->data, skb->len, DMA_TO_DEVICE));
+        CBDW_DATLEN(bdp, skb->len);
+
+        dev->trans_start = jiffies;
+
+        /*
+         * If this was the last BD in the ring, start at the beginning again. 
+         */
+        if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
+                fep->cur_tx++;
+        else
+                fep->cur_tx = fep->tx_bd_base;
+
+        if (!--fep->tx_free)
+                netif_stop_queue(dev);
+
+        /* Trigger transmission start */
+        sc = BD_ENET_TX_READY | BD_ENET_TX_INTR |
+             BD_ENET_TX_LAST | BD_ENET_TX_TC;
+
+        /* note that while FEC does not have this bit
+         * it marks it as available for software use
+         * yay for hw reuse :) */
+        if (skb->len <= 60)
+                sc |= BD_ENET_TX_PAD;
+        CBDS_SC(bdp, sc);
+
+        (*fep->ops->tx_kickstart)(dev);
+
+        spin_unlock_irqrestore(&fep->tx_lock, flags);
+
+        return NETDEV_TX_OK;
+}
+
+static int fs_request_irq(struct net_device *dev, int irq, const char *name,
+                irqreturn_t (*irqf)(int irq, void *dev_id, struct pt_regs *regs))
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        (*fep->ops->pre_request_irq)(dev, irq);
+        return request_irq(irq, irqf, SA_SHIRQ, name, dev);
+}
+
+static void fs_free_irq(struct net_device *dev, int irq)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        free_irq(irq, dev);
+        (*fep->ops->post_free_irq)(dev, irq);
+}
+
+/**********************************************************************************/
+
+/* This interrupt occurs when the PHY detects a link change. */
+static irqreturn_t
+fs_mii_link_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct fs_enet_private *fep;
+        const struct fs_platform_info *fpi;
+
+        fep = netdev_priv(dev);
+        fpi = fep->fpi;
+
+        /*
+         * Acknowledge the interrupt if possible. If we have not
+         * found the PHY yet we can't process or acknowledge the
+         * interrupt now. Instead we ignore this interrupt for now,
+         * which we can do since it is edge triggered. It will be
+         * acknowledged later by fs_enet_open().
+         */
+        if (!fep->phy)
+                return IRQ_NONE;
+
+        fs_mii_ack_int(dev);
+        fs_mii_link_status_change_check(dev, 0);
+
+        return IRQ_HANDLED;
+}
+
+static void fs_timeout(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int wake = 0;
+
+        fep->stats.tx_errors++;
+
+        spin_lock_irqsave(&fep->lock, flags);
+
+        if (dev->flags & IFF_UP) {
+                (*fep->ops->stop)(dev);
+                (*fep->ops->restart)(dev);
+        }
+
+        wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        if (wake)
+                netif_wake_queue(dev);
+}
+
+static int fs_enet_open(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        int r;
+
+        /* Install our interrupt handler. */
+        r = fs_request_irq(dev, fep->interrupt, "fs_enet-mac", fs_enet_interrupt);
+        if (r != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s Could not allocate FEC IRQ!", dev->name);
+                return -EINVAL;
+        }
+
+        /* Install our phy interrupt handler */
+        if (fpi->phy_irq != -1) {
+
+                r = fs_request_irq(dev, fpi->phy_irq, "fs_enet-phy", fs_mii_link_interrupt);
+                if (r != 0) {
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               ": %s Could not allocate PHY IRQ!", dev->name);
+                        fs_free_irq(dev, fep->interrupt);
+                        return -EINVAL;
+                }
+        }
+
+        fs_mii_startup(dev);
+        netif_carrier_off(dev);
+        fs_mii_link_status_change_check(dev, 1);
+
+        return 0;
+}
+
+static int fs_enet_close(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        unsigned long flags;
+
+        netif_stop_queue(dev);
+        netif_carrier_off(dev);
+        fs_mii_shutdown(dev);
+
+        spin_lock_irqsave(&fep->lock, flags);
+        (*fep->ops->stop)(dev);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        /* release any irqs */
+        if (fpi->phy_irq != -1)
+                fs_free_irq(dev, fpi->phy_irq);
+        fs_free_irq(dev, fep->interrupt);
+
+        return 0;
+}
+
+static struct net_device_stats *fs_enet_get_stats(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        return &fep->stats;
+}
+
+/*************************************************************************/
+
+static void fs_get_drvinfo(struct net_device *dev,
+                            struct ethtool_drvinfo *info)
+{
+        strcpy(info->driver, DRV_MODULE_NAME);
+        strcpy(info->version, DRV_MODULE_VERSION);
+}
+
+static int fs_get_regs_len(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        return (*fep->ops->get_regs_len)(dev);
+}
+
+static void fs_get_regs(struct net_device *dev, struct ethtool_regs *regs,
+                         void *p)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int r, len;
+
+        len = regs->len;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        r = (*fep->ops->get_regs)(dev, p, &len);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        if (r == 0)
+                regs->version = 0;
+}
+
+static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        rc = mii_ethtool_gset(&fep->mii_if, cmd);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        return rc;
+}
+
+static int fs_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        rc = mii_ethtool_sset(&fep->mii_if, cmd);
+        spin_unlock_irqrestore(&fep->lock, flags);
+
+        return rc;
+}
+
+static int fs_nway_reset(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        return mii_nway_restart(&fep->mii_if);
+}
+
+static u32 fs_get_msglevel(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        return fep->msg_enable;
+}
+
+static void fs_set_msglevel(struct net_device *dev, u32 value)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fep->msg_enable = value;
+}
+
+static struct ethtool_ops fs_ethtool_ops = {
+        .get_drvinfo = fs_get_drvinfo,
+        .get_regs_len = fs_get_regs_len,
+        .get_settings = fs_get_settings,
+        .set_settings = fs_set_settings,
+        .nway_reset = fs_nway_reset,
+        .get_link = ethtool_op_get_link,
+        .get_msglevel = fs_get_msglevel,
+        .set_msglevel = fs_set_msglevel,
+        .get_tx_csum = ethtool_op_get_tx_csum,
+        .set_tx_csum = ethtool_op_set_tx_csum,  /* local! */
+        .get_sg = ethtool_op_get_sg,
+        .set_sg = ethtool_op_set_sg,
+        .get_regs = fs_get_regs,
+};
+
+static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
+        unsigned long flags;
+        int rc;
+
+        if (!netif_running(dev))
+                return -EINVAL;
+
+        spin_lock_irqsave(&fep->lock, flags);
+        rc = generic_mii_ioctl(&fep->mii_if, mii, cmd, NULL);
+        spin_unlock_irqrestore(&fep->lock, flags);
+        return rc;
+}
+
+extern int fs_mii_connect(struct net_device *dev);
+extern void fs_mii_disconnect(struct net_device *dev);
+
+static struct net_device *fs_init_instance(struct device *dev,
+                const struct fs_platform_info *fpi)
+{
+        struct net_device *ndev = NULL;
+        struct fs_enet_private *fep = NULL;
+        int privsize, i, r, err = 0, registered = 0;
+
+        /* guard */
+        if ((unsigned int)fpi->fs_no >= FS_MAX_INDEX)
+                return ERR_PTR(-EINVAL);
+
+        privsize = sizeof(*fep) + (sizeof(struct sk_buff **) *
+                            (fpi->rx_ring + fpi->tx_ring));
+
+        ndev = alloc_etherdev(privsize);
+        if (!ndev) {
+                err = -ENOMEM;
+                goto err;
+        }
+        SET_MODULE_OWNER(ndev);
+
+        fep = netdev_priv(ndev);
+        memset(fep, 0, privsize);       /* clear everything */
+
+        fep->dev = dev;
+        dev_set_drvdata(dev, ndev);
+        fep->fpi = fpi;
+        if (fpi->init_ioports)
+                fpi->init_ioports();
+
+#ifdef CONFIG_FS_ENET_HAS_FEC
+        if (fs_get_fec_index(fpi->fs_no) >= 0)
+                fep->ops = &fs_fec_ops;
+#endif
+
+#ifdef CONFIG_FS_ENET_HAS_SCC
+        if (fs_get_scc_index(fpi->fs_no) >=0 )
+                fep->ops = &fs_scc_ops;
+#endif
+
+#ifdef CONFIG_FS_ENET_HAS_FCC
+        if (fs_get_fcc_index(fpi->fs_no) >= 0)
+                fep->ops = &fs_fcc_ops;
+#endif
+
+        if (fep->ops == NULL) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s No matching ops found (%d).\n",
+                       ndev->name, fpi->fs_no);
+                err = -EINVAL;
+                goto err;
+        }
+
+        r = (*fep->ops->setup_data)(ndev);
+        if (r != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s setup_data failed\n",
+                        ndev->name);
+                err = r;
+                goto err;
+        }
+
+        /* point rx_skbuff, tx_skbuff */
+        fep->rx_skbuff = (struct sk_buff **)&fep[1];
+        fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
+
+        /* init locks */
+        spin_lock_init(&fep->lock);
+        spin_lock_init(&fep->tx_lock);
+
+        /*
+         * Set the Ethernet address. 
+         */
+        for (i = 0; i < 6; i++)
+                ndev->dev_addr[i] = fpi->macaddr[i];
+        
+        r = (*fep->ops->allocate_bd)(ndev);
+        
+        if (fep->ring_base == NULL) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s buffer descriptor alloc failed (%d).\n", ndev->name, r);
+                err = r;
+                goto err;
+        }
+
+        /*
+         * Set receive and transmit descriptor base.
+         */
+        fep->rx_bd_base = fep->ring_base;
+        fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
+
+        /* initialize ring size variables */
+        fep->tx_ring = fpi->tx_ring;
+        fep->rx_ring = fpi->rx_ring;
+
+        /*
+         * The FEC Ethernet specific entries in the device structure. 
+         */
+        ndev->open = fs_enet_open;
+        ndev->hard_start_xmit = fs_enet_start_xmit;
+        ndev->tx_timeout = fs_timeout;
+        ndev->watchdog_timeo = 2 * HZ;
+        ndev->stop = fs_enet_close;
+        ndev->get_stats = fs_enet_get_stats;
+        ndev->set_multicast_list = fs_set_multicast_list;
+        if (fpi->use_napi) {
+                ndev->poll = fs_enet_rx_napi;
+                ndev->weight = fpi->napi_weight;
+        }
+        ndev->ethtool_ops = &fs_ethtool_ops;
+        ndev->do_ioctl = fs_ioctl;
+
+        init_timer(&fep->phy_timer_list);
+
+        netif_carrier_off(ndev);
+
+        err = register_netdev(ndev);
+        if (err != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s register_netdev failed.\n", ndev->name);
+                goto err;
+        }
+        registered = 1;
+
+        err = fs_mii_connect(ndev);
+        if (err != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s fs_mii_connect failed.\n", ndev->name);
+                goto err;
+        }
+
+        return ndev;
+
+      err:
+        if (ndev != NULL) {
+
+                if (registered)
+                        unregister_netdev(ndev);
+
+                if (fep != NULL) {
+                        (*fep->ops->free_bd)(ndev);
+                        (*fep->ops->cleanup_data)(ndev);
+                }
+
+                free_netdev(ndev);
+        }
+
+        dev_set_drvdata(dev, NULL);
+
+        return ERR_PTR(err);
+}
+
+static int fs_cleanup_instance(struct net_device *ndev)
+{
+        struct fs_enet_private *fep;
+        const struct fs_platform_info *fpi;
+        struct device *dev;
+
+        if (ndev == NULL)
+                return -EINVAL;
+
+        fep = netdev_priv(ndev);
+        if (fep == NULL)
+                return -EINVAL;
+
+        fpi = fep->fpi;
+
+        fs_mii_disconnect(ndev);
+
+        unregister_netdev(ndev);
+
+        dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
+                          fep->ring_base, fep->ring_mem_addr);
+
+        /* reset it */
+        (*fep->ops->cleanup_data)(ndev);
+
+        dev = fep->dev;
+        if (dev != NULL) {
+                dev_set_drvdata(dev, NULL);
+                fep->dev = NULL;
+        }
+
+        free_netdev(ndev);
+
+        return 0;
+}
+
+/**************************************************************************************/
+
+/* handy pointer to the immap */
+void *fs_enet_immap = NULL;
+
+static int setup_immap(void)
+{
+        phys_addr_t paddr = 0;
+        unsigned long size = 0;
+
+#ifdef CONFIG_CPM1
+        paddr = IMAP_ADDR;
+        size = 0x10000; /* map 64K */
+#endif
+
+#ifdef CONFIG_CPM2
+        paddr = CPM_MAP_ADDR;
+        size = 0x40000; /* map 256 K */
+#endif
+        fs_enet_immap = ioremap(paddr, size);
+        if (fs_enet_immap == NULL)
+                return -EBADF;  /* XXX ahem; maybe just BUG_ON? */
+
+        return 0;
+}
+
+static void cleanup_immap(void)
+{
+        if (fs_enet_immap != NULL) {
+                iounmap(fs_enet_immap);
+                fs_enet_immap = NULL;
+        }
+}
+
+/**************************************************************************************/
+
+static int __devinit fs_enet_probe(struct device *dev)
+{
+        struct net_device *ndev;
+
+        /* no fixup - no device */
+        if (dev->platform_data == NULL) {
+                printk(KERN_INFO "fs_enet: "
+                                "probe called with no platform data; "
+                                "remove unused devices\n");
+                return -ENODEV;
+        }
+
+        ndev = fs_init_instance(dev, dev->platform_data);
+        if (IS_ERR(ndev))
+                return PTR_ERR(ndev);
+        return 0;
+}
+
+static int fs_enet_remove(struct device *dev)
+{
+        return fs_cleanup_instance(dev_get_drvdata(dev));
+}
+
+static struct device_driver fs_enet_fec_driver = {
+        .name           = "fsl-cpm-fec",
+        .bus            = &platform_bus_type,
+        .probe          = fs_enet_probe,
+        .remove         = fs_enet_remove,
+#ifdef CONFIG_PM
+/*      .suspend        = fs_enet_suspend,      TODO */
+/*      .resume         = fs_enet_resume,       TODO */
+#endif
+};
+
+static struct device_driver fs_enet_scc_driver = {
+        .name           = "fsl-cpm-scc",
+        .bus            = &platform_bus_type,
+        .probe          = fs_enet_probe,
+        .remove         = fs_enet_remove,
+#ifdef CONFIG_PM
+/*      .suspend        = fs_enet_suspend,      TODO */
+/*      .resume         = fs_enet_resume,       TODO */
+#endif
+};
+
+static struct device_driver fs_enet_fcc_driver = {
+        .name           = "fsl-cpm-fcc",
+        .bus            = &platform_bus_type,
+        .probe          = fs_enet_probe,
+        .remove         = fs_enet_remove,
+#ifdef CONFIG_PM
+/*      .suspend        = fs_enet_suspend,      TODO */
+/*      .resume         = fs_enet_resume,       TODO */
+#endif
+};
+
+static int __init fs_init(void)
+{
+        int r;
+
+        printk(KERN_INFO
+                        "%s", version);
+
+        r = setup_immap();
+        if (r != 0)
+                return r;
+        r = driver_register(&fs_enet_fec_driver);
+        if (r != 0)
+                goto err;
+
+        r = driver_register(&fs_enet_fcc_driver);
+        if (r != 0)
+                goto err;
+
+        r = driver_register(&fs_enet_scc_driver);
+        if (r != 0)
+                goto err;
+
+        return 0;
+err:
+        cleanup_immap();
+        return r;
+        
+}
+
+static void __exit fs_cleanup(void)
+{
+        driver_unregister(&fs_enet_fec_driver);
+        driver_unregister(&fs_enet_fcc_driver);
+        driver_unregister(&fs_enet_scc_driver);
+        cleanup_immap();
+}
+
+/**************************************************************************************/
+
+module_init(fs_init);
+module_exit(fs_cleanup);
diff --git a/drivers/net/fs_enet/fs_enet-mii.c b/drivers/net/fs_enet/fs_enet-mii.c
new file mode 100644
index 000000000000..c6770377ef87
--- /dev/null
+++ b/drivers/net/fs_enet/fs_enet-mii.c
@@ -0,0 +1,507 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
+ * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+/*
+ * Generic PHY support.
+ * Should work for all PHYs, but link change is detected by polling
+ */
+
+static void generic_timer_callback(unsigned long data)
+{
+        struct net_device *dev = (struct net_device *)data;
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fep->phy_timer_list.expires = jiffies + HZ / 2;
+
+        add_timer(&fep->phy_timer_list);
+
+        fs_mii_link_status_change_check(dev, 0);
+}
+
+static void generic_startup(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fep->phy_timer_list.expires = jiffies + HZ / 2; /* every 500ms */
+        fep->phy_timer_list.data = (unsigned long)dev;
+        fep->phy_timer_list.function = generic_timer_callback;
+        add_timer(&fep->phy_timer_list);
+}
+
+static void generic_shutdown(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        del_timer_sync(&fep->phy_timer_list);
+}
+
+/* ------------------------------------------------------------------------- */
+/* The Davicom DM9161 is used on the NETTA board                             */
+
+/* register definitions */
+
+#define MII_DM9161_ANAR         4       /* Aux. Config Register         */
+#define MII_DM9161_ACR          16      /* Aux. Config Register         */
+#define MII_DM9161_ACSR         17      /* Aux. Config/Status Register  */
+#define MII_DM9161_10TCSR       18      /* 10BaseT Config/Status Reg.   */
+#define MII_DM9161_INTR         21      /* Interrupt Register           */
+#define MII_DM9161_RECR         22      /* Receive Error Counter Reg.   */
+#define MII_DM9161_DISCR        23      /* Disconnect Counter Register  */
+
+static void dm9161_startup(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fs_mii_write(dev, fep->mii_if.phy_id, MII_DM9161_INTR, 0x0000);
+        /* Start autonegotiation */
+        fs_mii_write(dev, fep->mii_if.phy_id, MII_BMCR, 0x1200);
+
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        schedule_timeout(HZ*8);
+}
+
+static void dm9161_ack_int(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fs_mii_read(dev, fep->mii_if.phy_id, MII_DM9161_INTR);
+}
+
+static void dm9161_shutdown(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fs_mii_write(dev, fep->mii_if.phy_id, MII_DM9161_INTR, 0x0f00);
+}
+
+/**********************************************************************************/
+
+static const struct phy_info phy_info[] = {
+        {
+                .id = 0x00181b88,
+                .name = "DM9161",
+                .startup = dm9161_startup,
+                .ack_int = dm9161_ack_int,
+                .shutdown = dm9161_shutdown,
+        }, {
+                .id = 0,
+                .name = "GENERIC",
+                .startup = generic_startup,
+                .shutdown = generic_shutdown,
+        },
+};
+
+/**********************************************************************************/
+
+static int phy_id_detect(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+        int i, r, start, end, phytype, physubtype;
+        const struct phy_info *phy;
+        int phy_hwid, phy_id;
+
+        phy_hwid = -1;
+        fep->phy = NULL;
+
+        /* auto-detect? */
+        if (fpi->phy_addr == -1) {
+                start = 1;
+                end = 32;
+        } else {                /* direct */
+                start = fpi->phy_addr;
+                end = start + 1;
+        }
+
+        for (phy_id = start; phy_id < end; phy_id++) {
+                /* skip already used phy addresses on this bus */ 
+                if (bus->usage_map & (1 << phy_id))
+                        continue;
+                r = fs_mii_read(dev, phy_id, MII_PHYSID1);
+                if (r == -1 || (phytype = (r & 0xffff)) == 0xffff)
+                        continue;
+                r = fs_mii_read(dev, phy_id, MII_PHYSID2);
+                if (r == -1 || (physubtype = (r & 0xffff)) == 0xffff)
+                        continue;
+                phy_hwid = (phytype << 16) | physubtype;
+                if (phy_hwid != -1)
+                        break;
+        }
+
+        if (phy_hwid == -1) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s No PHY detected! range=0x%02x-0x%02x\n",
+                        dev->name, start, end);
+                return -1;
+        }
+
+        for (i = 0, phy = phy_info; i < ARRAY_SIZE(phy_info); i++, phy++)
+                if (phy->id == (phy_hwid >> 4) || phy->id == 0)
+                        break;
+
+        if (i >= ARRAY_SIZE(phy_info)) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       ": %s PHY id 0x%08x is not supported!\n",
+                       dev->name, phy_hwid);
+                return -1;
+        }
+
+        fep->phy = phy;
+
+        /* mark this address as used */
+        bus->usage_map |= (1 << phy_id);
+
+        printk(KERN_INFO DRV_MODULE_NAME
+               ": %s Phy @ 0x%x, type %s (0x%08x)%s\n",
+               dev->name, phy_id, fep->phy->name, phy_hwid,
+               fpi->phy_addr == -1 ? " (auto-detected)" : "");
+
+        return phy_id;
+}
+
+void fs_mii_startup(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->phy->startup)
+                (*fep->phy->startup) (dev);
+}
+
+void fs_mii_shutdown(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->phy->shutdown)
+                (*fep->phy->shutdown) (dev);
+}
+
+void fs_mii_ack_int(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->phy->ack_int)
+                (*fep->phy->ack_int) (dev);
+}
+
+#define MII_LINK        0x0001
+#define MII_HALF        0x0002
+#define MII_FULL        0x0004
+#define MII_BASE4       0x0008
+#define MII_10M         0x0010
+#define MII_100M        0x0020
+#define MII_1G          0x0040
+#define MII_10G         0x0080
+
+/* return full mii info at one gulp, with a usable form */
+static unsigned int mii_full_status(struct mii_if_info *mii)
+{
+        unsigned int status;
+        int bmsr, adv, lpa, neg;
+        struct fs_enet_private* fep = netdev_priv(mii->dev);
+        
+        /* first, a dummy read, needed to latch some MII phys */
+        (void)mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+        bmsr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+
+        /* no link */
+        if ((bmsr & BMSR_LSTATUS) == 0)
+                return 0;
+
+        status = MII_LINK;
+        
+        /* Lets look what ANEG says if it's supported - otherwize we shall
+           take the right values from the platform info*/
+        if(!mii->force_media) {
+                /* autoneg not completed; don't bother */
+                if ((bmsr & BMSR_ANEGCOMPLETE) == 0)
+                        return 0;
+
+                adv = (*mii->mdio_read)(mii->dev, mii->phy_id, MII_ADVERTISE);
+                lpa = (*mii->mdio_read)(mii->dev, mii->phy_id, MII_LPA);
+
+                neg = lpa & adv;
+        } else {
+                neg = fep->fpi->bus_info->lpa;
+        }
+
+        if (neg & LPA_100FULL)
+                status |= MII_FULL | MII_100M;
+        else if (neg & LPA_100BASE4)
+                status |= MII_FULL | MII_BASE4 | MII_100M;
+        else if (neg & LPA_100HALF)
+                status |= MII_HALF | MII_100M;
+        else if (neg & LPA_10FULL)
+                status |= MII_FULL | MII_10M;
+        else
+                status |= MII_HALF | MII_10M;
+        
+        return status;
+}
+
+void fs_mii_link_status_change_check(struct net_device *dev, int init_media)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct mii_if_info *mii = &fep->mii_if;
+        unsigned int mii_status;
+        int ok_to_print, link, duplex, speed;
+        unsigned long flags;
+
+        ok_to_print = netif_msg_link(fep);
+
+        mii_status = mii_full_status(mii);
+
+        if (!init_media && mii_status == fep->last_mii_status)
+                return;
+
+        fep->last_mii_status = mii_status;
+
+        link = !!(mii_status & MII_LINK);
+        duplex = !!(mii_status & MII_FULL);
+        speed = (mii_status & MII_100M) ? 100 : 10;
+
+        if (link == 0) {
+                netif_carrier_off(mii->dev);
+                netif_stop_queue(dev);
+                if (!init_media) {
+                        spin_lock_irqsave(&fep->lock, flags);
+                        (*fep->ops->stop)(dev);
+                        spin_unlock_irqrestore(&fep->lock, flags);
+                }
+
+                if (ok_to_print)
+                        printk(KERN_INFO "%s: link down\n", mii->dev->name);
+
+        } else {
+
+                mii->full_duplex = duplex;
+
+                netif_carrier_on(mii->dev);
+
+                spin_lock_irqsave(&fep->lock, flags);
+                fep->duplex = duplex;
+                fep->speed = speed;
+                (*fep->ops->restart)(dev);
+                spin_unlock_irqrestore(&fep->lock, flags);
+
+                netif_start_queue(dev);
+
+                if (ok_to_print)
+                        printk(KERN_INFO "%s: link up, %dMbps, %s-duplex\n",
+                               dev->name, speed, duplex ? "full" : "half");
+        }
+}
+
+/**********************************************************************************/
+
+int fs_mii_read(struct net_device *dev, int phy_id, int location)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&bus->mii_lock, flags);
+        ret = (*bus->mii_read)(bus, phy_id, location);
+        spin_unlock_irqrestore(&bus->mii_lock, flags);
+
+        return ret;
+}
+
+void fs_mii_write(struct net_device *dev, int phy_id, int location, int value)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+        unsigned long flags;
+
+        spin_lock_irqsave(&bus->mii_lock, flags);
+        (*bus->mii_write)(bus, phy_id, location, value);
+        spin_unlock_irqrestore(&bus->mii_lock, flags);
+}
+
+/*****************************************************************************/
+
+/* list of all registered mii buses */
+static LIST_HEAD(fs_mii_bus_list);
+
+static struct fs_enet_mii_bus *lookup_bus(int method, int id)
+{
+        struct list_head *ptr;
+        struct fs_enet_mii_bus *bus;
+
+        list_for_each(ptr, &fs_mii_bus_list) {
+                bus = list_entry(ptr, struct fs_enet_mii_bus, list);
+                if (bus->bus_info->method == method &&
+                        bus->bus_info->id == id)
+                        return bus;
+        }
+        return NULL;
+}
+
+static struct fs_enet_mii_bus *create_bus(const struct fs_mii_bus_info *bi)
+{
+        struct fs_enet_mii_bus *bus;
+        int ret = 0;
+
+        bus = kmalloc(sizeof(*bus), GFP_KERNEL);
+        if (bus == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        memset(bus, 0, sizeof(*bus));
+        spin_lock_init(&bus->mii_lock);
+        bus->bus_info = bi;
+        bus->refs = 0;
+        bus->usage_map = 0;
+
+        /* perform initialization */
+        switch (bi->method) {
+
+                case fsmii_fixed:
+                        ret = fs_mii_fixed_init(bus);
+                        if (ret != 0)
+                                goto err;
+                        break;
+
+                case fsmii_bitbang:
+                        ret = fs_mii_bitbang_init(bus);
+                        if (ret != 0)
+                                goto err;
+                        break;
+#ifdef CONFIG_FS_ENET_HAS_FEC
+                case fsmii_fec:
+                        ret = fs_mii_fec_init(bus);
+                        if (ret != 0)
+                                goto err;
+                        break;
+#endif
+                default:
+                        ret = -EINVAL;
+                        goto err;
+        }
+
+        list_add(&bus->list, &fs_mii_bus_list);
+
+        return bus;
+
+err:
+        if (bus)
+                kfree(bus);
+        return ERR_PTR(ret);
+}
+
+static void destroy_bus(struct fs_enet_mii_bus *bus)
+{
+        /* remove from bus list */
+        list_del(&bus->list);
+
+        /* nothing more needed */
+        kfree(bus);
+}
+
+int fs_mii_connect(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        struct fs_enet_mii_bus *bus = NULL;
+
+        /* check method validity */
+        switch (fpi->bus_info->method) {
+                case fsmii_fixed:
+                case fsmii_bitbang:
+                        break;
+#ifdef CONFIG_FS_ENET_HAS_FEC
+                case fsmii_fec:
+                        break;
+#endif
+                default:
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               ": %s Unknown MII bus method (%d)!\n",
+                               dev->name, fpi->bus_info->method);
+                        return -EINVAL; 
+        }
+
+        bus = lookup_bus(fpi->bus_info->method, fpi->bus_info->id);
+
+        /* if not found create new bus */
+        if (bus == NULL) {
+                bus = create_bus(fpi->bus_info);
+                if (IS_ERR(bus)) {
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               ": %s MII bus creation failure!\n", dev->name);
+                        return PTR_ERR(bus);
+                }
+        }
+
+        bus->refs++;
+
+        fep->mii_bus = bus;
+
+        fep->mii_if.dev = dev;
+        fep->mii_if.phy_id_mask = 0x1f;
+        fep->mii_if.reg_num_mask = 0x1f;
+        fep->mii_if.mdio_read = fs_mii_read;
+        fep->mii_if.mdio_write = fs_mii_write;
+        fep->mii_if.force_media = fpi->bus_info->disable_aneg;
+        fep->mii_if.phy_id = phy_id_detect(dev);
+
+        return 0;
+}
+
+void fs_mii_disconnect(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        struct fs_enet_mii_bus *bus = NULL;
+
+        bus = fep->mii_bus;
+        fep->mii_bus = NULL;
+
+        if (--bus->refs <= 0)
+                destroy_bus(bus);
+}
diff --git a/drivers/net/fs_enet/fs_enet.h b/drivers/net/fs_enet/fs_enet.h
new file mode 100644
index 000000000000..1105543b9d88
--- /dev/null
+++ b/drivers/net/fs_enet/fs_enet.h
@@ -0,0 +1,245 @@
+#ifndef FS_ENET_H
+#define FS_ENET_H
+
+#include <linux/mii.h>
+#include <linux/netdevice.h>
+#include <linux/types.h>
+#include <linux/version.h>
+#include <linux/list.h>
+
+#include <linux/fs_enet_pd.h>
+
+#include <asm/dma-mapping.h>
+
+#ifdef CONFIG_CPM1
+#include <asm/commproc.h>
+#endif
+
+#ifdef CONFIG_CPM2
+#include <asm/cpm2.h>
+#endif
+
+/* hw driver ops */
+struct fs_ops {
+        int (*setup_data)(struct net_device *dev);
+        int (*allocate_bd)(struct net_device *dev);
+        void (*free_bd)(struct net_device *dev);
+        void (*cleanup_data)(struct net_device *dev);
+        void (*set_multicast_list)(struct net_device *dev);
+        void (*restart)(struct net_device *dev);
+        void (*stop)(struct net_device *dev);
+        void (*pre_request_irq)(struct net_device *dev, int irq);
+        void (*post_free_irq)(struct net_device *dev, int irq);
+        void (*napi_clear_rx_event)(struct net_device *dev);
+        void (*napi_enable_rx)(struct net_device *dev);
+        void (*napi_disable_rx)(struct net_device *dev);
+        void (*rx_bd_done)(struct net_device *dev);
+        void (*tx_kickstart)(struct net_device *dev);
+        u32 (*get_int_events)(struct net_device *dev);
+        void (*clear_int_events)(struct net_device *dev, u32 int_events);
+        void (*ev_error)(struct net_device *dev, u32 int_events);
+        int (*get_regs)(struct net_device *dev, void *p, int *sizep);
+        int (*get_regs_len)(struct net_device *dev);
+        void (*tx_restart)(struct net_device *dev);
+};
+
+struct phy_info {
+        unsigned int id;
+        const char *name;
+        void (*startup) (struct net_device * dev);
+        void (*shutdown) (struct net_device * dev);
+        void (*ack_int) (struct net_device * dev);
+};
+
+/* The FEC stores dest/src/type, data, and checksum for receive packets.
+ */
+#define MAX_MTU 1508            /* Allow fullsized pppoe packets over VLAN */
+#define MIN_MTU 46              /* this is data size */
+#define CRC_LEN 4
+
+#define PKT_MAXBUF_SIZE         (MAX_MTU+ETH_HLEN+CRC_LEN)
+#define PKT_MINBUF_SIZE         (MIN_MTU+ETH_HLEN+CRC_LEN)
+
+/* Must be a multiple of 32 (to cover both FEC & FCC) */
+#define PKT_MAXBLR_SIZE         ((PKT_MAXBUF_SIZE + 31) & ~31)
+/* This is needed so that invalidate_xxx wont invalidate too much */
+#define ENET_RX_FRSIZE          L1_CACHE_ALIGN(PKT_MAXBUF_SIZE)
+
+struct fs_enet_mii_bus {
+        struct list_head list;
+        spinlock_t mii_lock;
+        const struct fs_mii_bus_info *bus_info;
+        int refs;
+        u32 usage_map;
+
+        int (*mii_read)(struct fs_enet_mii_bus *bus,
+                        int phy_id, int location);
+
+        void (*mii_write)(struct fs_enet_mii_bus *bus,
+                        int phy_id, int location, int value);
+
+        union {
+                struct {
+                        unsigned int mii_speed;
+                        void *fecp;
+                } fec;
+
+                struct {
+                        /* note that the actual port size may */
+                        /* be different; cpm(s) handle it OK  */
+                        u8 mdio_msk;
+                        u8 *mdio_dir;
+                        u8 *mdio_dat;
+                        u8 mdc_msk;
+                        u8 *mdc_dir;
+                        u8 *mdc_dat;
+                } bitbang;
+
+                struct {
+                        u16 lpa;
+                } fixed;
+        };
+};
+
+int fs_mii_bitbang_init(struct fs_enet_mii_bus *bus);
+int fs_mii_fixed_init(struct fs_enet_mii_bus *bus);
+int fs_mii_fec_init(struct fs_enet_mii_bus *bus);
+
+struct fs_enet_private {
+        struct device *dev;     /* pointer back to the device (must be initialized first) */
+        spinlock_t lock;        /* during all ops except TX pckt processing */
+        spinlock_t tx_lock;     /* during fs_start_xmit and fs_tx         */
+        const struct fs_platform_info *fpi;
+        const struct fs_ops *ops;
+        int rx_ring, tx_ring;
+        dma_addr_t ring_mem_addr;
+        void *ring_base;
+        struct sk_buff **rx_skbuff;
+        struct sk_buff **tx_skbuff;
+        cbd_t *rx_bd_base;      /* Address of Rx and Tx buffers.    */
+        cbd_t *tx_bd_base;
+        cbd_t *dirty_tx;        /* ring entries to be free()ed.     */
+        cbd_t *cur_rx;
+        cbd_t *cur_tx;
+        int tx_free;
+        struct net_device_stats stats;
+        struct timer_list phy_timer_list;
+        const struct phy_info *phy;
+        u32 msg_enable;
+        struct mii_if_info mii_if;
+        unsigned int last_mii_status;
+        struct fs_enet_mii_bus *mii_bus;
+        int interrupt;
+
+        int duplex, speed;      /* current settings */
+
+        /* event masks */
+        u32 ev_napi_rx;         /* mask of NAPI rx events */
+        u32 ev_rx;              /* rx event mask          */
+        u32 ev_tx;              /* tx event mask          */
+        u32 ev_err;             /* error event mask       */
+
+        u16 bd_rx_empty;        /* mask of BD rx empty    */
+        u16 bd_rx_err;          /* mask of BD rx errors   */
+
+        union {
+                struct {
+                        int idx;                /* FEC1 = 0, FEC2 = 1  */
+                        void *fecp;             /* hw registers        */
+                        u32 hthi, htlo;         /* state for multicast */
+                } fec;
+
+                struct {
+                        int idx;                /* FCC1-3 = 0-2        */
+                        void *fccp;             /* hw registers        */
+                        void *ep;               /* parameter ram       */
+                        void *fcccp;            /* hw registers cont.  */
+                        void *mem;              /* FCC DPRAM */
+                        u32 gaddrh, gaddrl;     /* group address       */
+                } fcc;
+
+                struct {
+                        int idx;                /* FEC1 = 0, FEC2 = 1  */
+                        void *sccp;             /* hw registers        */
+                        void *ep;               /* parameter ram       */
+                        u32 hthi, htlo;         /* state for multicast */
+                } scc;
+
+        };
+};
+
+/***************************************************************************/
+
+int fs_mii_read(struct net_device *dev, int phy_id, int location);
+void fs_mii_write(struct net_device *dev, int phy_id, int location, int value);
+
+void fs_mii_startup(struct net_device *dev);
+void fs_mii_shutdown(struct net_device *dev);
+void fs_mii_ack_int(struct net_device *dev);
+
+void fs_mii_link_status_change_check(struct net_device *dev, int init_media);
+
+void fs_init_bds(struct net_device *dev);
+void fs_cleanup_bds(struct net_device *dev);
+
+/***************************************************************************/
+
+#define DRV_MODULE_NAME         "fs_enet"
+#define PFX DRV_MODULE_NAME     ": "
+#define DRV_MODULE_VERSION      "1.0"
+#define DRV_MODULE_RELDATE      "Aug 8, 2005"
+
+/***************************************************************************/
+
+int fs_enet_platform_init(void);
+void fs_enet_platform_cleanup(void);
+
+/***************************************************************************/
+
+/* buffer descriptor access macros */
+
+/* access macros */
+#if defined(CONFIG_CPM1)
+/* for a a CPM1 __raw_xxx's are sufficient */
+#define __cbd_out32(addr, x)    __raw_writel(x, addr)
+#define __cbd_out16(addr, x)    __raw_writew(x, addr)
+#define __cbd_in32(addr)        __raw_readl(addr)
+#define __cbd_in16(addr)        __raw_readw(addr)
+#else
+/* for others play it safe */
+#define __cbd_out32(addr, x)    out_be32(addr, x)
+#define __cbd_out16(addr, x)    out_be16(addr, x)
+#define __cbd_in32(addr)        in_be32(addr)
+#define __cbd_in16(addr)        in_be16(addr)
+#endif
+
+/* write */
+#define CBDW_SC(_cbd, _sc)              __cbd_out16(&(_cbd)->cbd_sc, (_sc))
+#define CBDW_DATLEN(_cbd, _datlen)      __cbd_out16(&(_cbd)->cbd_datlen, (_datlen))
+#define CBDW_BUFADDR(_cbd, _bufaddr)    __cbd_out32(&(_cbd)->cbd_bufaddr, (_bufaddr))
+
+/* read */
+#define CBDR_SC(_cbd)                   __cbd_in16(&(_cbd)->cbd_sc)
+#define CBDR_DATLEN(_cbd)               __cbd_in16(&(_cbd)->cbd_datlen)
+#define CBDR_BUFADDR(_cbd)              __cbd_in32(&(_cbd)->cbd_bufaddr)
+
+/* set bits */
+#define CBDS_SC(_cbd, _sc)              CBDW_SC(_cbd, CBDR_SC(_cbd) | (_sc))
+
+/* clear bits */
+#define CBDC_SC(_cbd, _sc)              CBDW_SC(_cbd, CBDR_SC(_cbd) & ~(_sc))
+
+/*******************************************************************/
+
+extern const struct fs_ops fs_fec_ops;
+extern const struct fs_ops fs_fcc_ops;
+extern const struct fs_ops fs_scc_ops;
+
+/*******************************************************************/
+
+/* handy pointer to the immap */
+extern void *fs_enet_immap;
+
+/*******************************************************************/
+
+#endif
diff --git a/drivers/net/fs_enet/mac-fcc.c b/drivers/net/fs_enet/mac-fcc.c
new file mode 100644
index 000000000000..a940b96433c7
--- /dev/null
+++ b/drivers/net/fs_enet/mac-fcc.c
@@ -0,0 +1,578 @@
+/*
+ * FCC driver for Motorola MPC82xx (PQ2).
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <asm/immap_cpm2.h>
+#include <asm/mpc8260.h>
+#include <asm/cpm2.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+/* FCC access macros */
+
+#define __fcc_out32(addr, x)    out_be32((unsigned *)addr, x)
+#define __fcc_out16(addr, x)    out_be16((unsigned short *)addr, x)
+#define __fcc_out8(addr, x)     out_8((unsigned char *)addr, x)
+#define __fcc_in32(addr)        in_be32((unsigned *)addr)
+#define __fcc_in16(addr)        in_be16((unsigned short *)addr)
+#define __fcc_in8(addr)         in_8((unsigned char *)addr)
+
+/* parameter space */
+
+/* write, read, set bits, clear bits */
+#define W32(_p, _m, _v) __fcc_out32(&(_p)->_m, (_v))
+#define R32(_p, _m)     __fcc_in32(&(_p)->_m)
+#define S32(_p, _m, _v) W32(_p, _m, R32(_p, _m) | (_v))
+#define C32(_p, _m, _v) W32(_p, _m, R32(_p, _m) & ~(_v))
+
+#define W16(_p, _m, _v) __fcc_out16(&(_p)->_m, (_v))
+#define R16(_p, _m)     __fcc_in16(&(_p)->_m)
+#define S16(_p, _m, _v) W16(_p, _m, R16(_p, _m) | (_v))
+#define C16(_p, _m, _v) W16(_p, _m, R16(_p, _m) & ~(_v))
+
+#define W8(_p, _m, _v)  __fcc_out8(&(_p)->_m, (_v))
+#define R8(_p, _m)      __fcc_in8(&(_p)->_m)
+#define S8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) | (_v))
+#define C8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) & ~(_v))
+
+/*************************************************/
+
+#define FCC_MAX_MULTICAST_ADDRS 64
+
+#define mk_mii_read(REG)        (0x60020000 | ((REG & 0x1f) << 18))
+#define mk_mii_write(REG, VAL)  (0x50020000 | ((REG & 0x1f) << 18) | (VAL & 0xffff))
+#define mk_mii_end              0
+
+#define MAX_CR_CMD_LOOPS        10000
+
+static inline int fcc_cr_cmd(struct fs_enet_private *fep, u32 mcn, u32 op)
+{
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        cpm2_map_t *immap = fs_enet_immap;
+        cpm_cpm2_t *cpmp = &immap->im_cpm;
+        u32 v;
+        int i;
+
+        /* Currently I don't know what feature call will look like. But 
+           I guess there'd be something like do_cpm_cmd() which will require page & sblock */
+        v = mk_cr_cmd(fpi->cp_page, fpi->cp_block, mcn, op);
+        W32(cpmp, cp_cpcr, v | CPM_CR_FLG);
+        for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
+                if ((R32(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
+                        break;
+
+        if (i >= MAX_CR_CMD_LOOPS) {
+                printk(KERN_ERR "%s(): Not able to issue CPM command\n",
+                       __FUNCTION__);
+                return 1;
+        }
+
+        return 0;
+}
+
+static int do_pd_setup(struct fs_enet_private *fep)
+{
+        struct platform_device *pdev = to_platform_device(fep->dev);
+        struct resource *r;
+
+        /* Fill out IRQ field */
+        fep->interrupt = platform_get_irq(pdev, 0);
+
+        /* Attach the memory for the FCC Parameter RAM */
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fcc_pram");
+        fep->fcc.ep = (void *)r->start;
+
+        if (fep->fcc.ep == NULL)
+                return -EINVAL;
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fcc_regs");
+        fep->fcc.fccp = (void *)r->start;
+
+        if (fep->fcc.fccp == NULL)
+                return -EINVAL;
+
+        fep->fcc.fcccp = (void *)fep->fpi->fcc_regs_c;
+
+        if (fep->fcc.fcccp == NULL)
+                return -EINVAL;
+
+        return 0;
+}
+
+#define FCC_NAPI_RX_EVENT_MSK   (FCC_ENET_RXF | FCC_ENET_RXB)
+#define FCC_RX_EVENT            (FCC_ENET_RXF)
+#define FCC_TX_EVENT            (FCC_ENET_TXB)
+#define FCC_ERR_EVENT_MSK       (FCC_ENET_TXE | FCC_ENET_BSY)
+
+static int setup_data(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->fcc.idx = fs_get_fcc_index(fpi->fs_no);
+        if ((unsigned int)fep->fcc.idx >= 3)    /* max 3 FCCs */
+                return -EINVAL;
+
+        fep->fcc.mem = (void *)fpi->mem_offset;
+
+        if (do_pd_setup(fep) != 0)
+                return -EINVAL;
+
+        fep->ev_napi_rx = FCC_NAPI_RX_EVENT_MSK;
+        fep->ev_rx = FCC_RX_EVENT;
+        fep->ev_tx = FCC_TX_EVENT;
+        fep->ev_err = FCC_ERR_EVENT_MSK;
+
+        return 0;
+}
+
+static int allocate_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->ring_base = dma_alloc_coherent(fep->dev,
+                                            (fpi->tx_ring + fpi->rx_ring) *
+                                            sizeof(cbd_t), &fep->ring_mem_addr,
+                                            GFP_KERNEL);
+        if (fep->ring_base == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void free_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        if (fep->ring_base)
+                dma_free_coherent(fep->dev,
+                        (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
+                        fep->ring_base, fep->ring_mem_addr);
+}
+
+static void cleanup_data(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void set_promiscuous_mode(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        S32(fccp, fcc_fpsmr, FCC_PSMR_PRO);
+}
+
+static void set_multicast_start(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_enet_t *ep = fep->fcc.ep;
+
+        W32(ep, fen_gaddrh, 0);
+        W32(ep, fen_gaddrl, 0);
+}
+
+static void set_multicast_one(struct net_device *dev, const u8 *mac)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_enet_t *ep = fep->fcc.ep;
+        u16 taddrh, taddrm, taddrl;
+
+        taddrh = ((u16)mac[5] << 8) | mac[4];
+        taddrm = ((u16)mac[3] << 8) | mac[2];
+        taddrl = ((u16)mac[1] << 8) | mac[0];
+
+        W16(ep, fen_taddrh, taddrh);
+        W16(ep, fen_taddrm, taddrm);
+        W16(ep, fen_taddrl, taddrl);
+        fcc_cr_cmd(fep, 0x0C, CPM_CR_SET_GADDR);
+}
+
+static void set_multicast_finish(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+        fcc_enet_t *ep = fep->fcc.ep;
+
+        /* clear promiscuous always */
+        C32(fccp, fcc_fpsmr, FCC_PSMR_PRO);
+
+        /* if all multi or too many multicasts; just enable all */
+        if ((dev->flags & IFF_ALLMULTI) != 0 ||
+            dev->mc_count > FCC_MAX_MULTICAST_ADDRS) {
+
+                W32(ep, fen_gaddrh, 0xffffffff);
+                W32(ep, fen_gaddrl, 0xffffffff);
+        }
+
+        /* read back */
+        fep->fcc.gaddrh = R32(ep, fen_gaddrh);
+        fep->fcc.gaddrl = R32(ep, fen_gaddrl);
+}
+
+static void set_multicast_list(struct net_device *dev)
+{
+        struct dev_mc_list *pmc;
+
+        if ((dev->flags & IFF_PROMISC) == 0) {
+                set_multicast_start(dev);
+                for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next)
+                        set_multicast_one(dev, pmc->dmi_addr);
+                set_multicast_finish(dev);
+        } else
+                set_promiscuous_mode(dev);
+}
+
+static void restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        fcc_t *fccp = fep->fcc.fccp;
+        fcc_c_t *fcccp = fep->fcc.fcccp;
+        fcc_enet_t *ep = fep->fcc.ep;
+        dma_addr_t rx_bd_base_phys, tx_bd_base_phys;
+        u16 paddrh, paddrm, paddrl;
+        u16 mem_addr;
+        const unsigned char *mac;
+        int i;
+
+        C32(fccp, fcc_gfmr, FCC_GFMR_ENR | FCC_GFMR_ENT);
+
+        /* clear everything (slow & steady does it) */
+        for (i = 0; i < sizeof(*ep); i++)
+                __fcc_out8((char *)ep + i, 0);
+
+        /* get physical address */
+        rx_bd_base_phys = fep->ring_mem_addr;
+        tx_bd_base_phys = rx_bd_base_phys + sizeof(cbd_t) * fpi->rx_ring;
+
+        /* point to bds */
+        W32(ep, fen_genfcc.fcc_rbase, rx_bd_base_phys);
+        W32(ep, fen_genfcc.fcc_tbase, tx_bd_base_phys);
+
+        /* Set maximum bytes per receive buffer.
+         * It must be a multiple of 32.
+         */
+        W16(ep, fen_genfcc.fcc_mrblr, PKT_MAXBLR_SIZE);
+
+        W32(ep, fen_genfcc.fcc_rstate, (CPMFCR_GBL | CPMFCR_EB) << 24);
+        W32(ep, fen_genfcc.fcc_tstate, (CPMFCR_GBL | CPMFCR_EB) << 24);
+
+        /* Allocate space in the reserved FCC area of DPRAM for the
+         * internal buffers.  No one uses this space (yet), so we
+         * can do this.  Later, we will add resource management for
+         * this area.
+         */
+
+        mem_addr = (u32) fep->fcc.mem;  /* de-fixup dpram offset */
+
+        W16(ep, fen_genfcc.fcc_riptr, (mem_addr & 0xffff));
+        W16(ep, fen_genfcc.fcc_tiptr, ((mem_addr + 32) & 0xffff));
+        W16(ep, fen_padptr, mem_addr + 64);
+
+        /* fill with special symbol...  */
+        memset(fep->fcc.mem + fpi->dpram_offset + 64, 0x88, 32);
+
+        W32(ep, fen_genfcc.fcc_rbptr, 0);
+        W32(ep, fen_genfcc.fcc_tbptr, 0);
+        W32(ep, fen_genfcc.fcc_rcrc, 0);
+        W32(ep, fen_genfcc.fcc_tcrc, 0);
+        W16(ep, fen_genfcc.fcc_res1, 0);
+        W32(ep, fen_genfcc.fcc_res2, 0);
+
+        /* no CAM */
+        W32(ep, fen_camptr, 0);
+
+        /* Set CRC preset and mask */
+        W32(ep, fen_cmask, 0xdebb20e3);
+        W32(ep, fen_cpres, 0xffffffff);
+
+        W32(ep, fen_crcec, 0);          /* CRC Error counter       */
+        W32(ep, fen_alec, 0);           /* alignment error counter */
+        W32(ep, fen_disfc, 0);          /* discard frame counter   */
+        W16(ep, fen_retlim, 15);        /* Retry limit threshold   */
+        W16(ep, fen_pper, 0);           /* Normal persistence      */
+
+        /* set group address */
+        W32(ep, fen_gaddrh, fep->fcc.gaddrh);
+        W32(ep, fen_gaddrl, fep->fcc.gaddrh);
+
+        /* Clear hash filter tables */
+        W32(ep, fen_iaddrh, 0);
+        W32(ep, fen_iaddrl, 0);
+
+        /* Clear the Out-of-sequence TxBD  */
+        W16(ep, fen_tfcstat, 0);
+        W16(ep, fen_tfclen, 0);
+        W32(ep, fen_tfcptr, 0);
+
+        W16(ep, fen_mflr, PKT_MAXBUF_SIZE);     /* maximum frame length register */
+        W16(ep, fen_minflr, PKT_MINBUF_SIZE);   /* minimum frame length register */
+
+        /* set address */
+        mac = dev->dev_addr;
+        paddrh = ((u16)mac[5] << 8) | mac[4];
+        paddrm = ((u16)mac[3] << 8) | mac[2];
+        paddrl = ((u16)mac[1] << 8) | mac[0];
+
+        W16(ep, fen_paddrh, paddrh);
+        W16(ep, fen_paddrm, paddrm);
+        W16(ep, fen_paddrl, paddrl);
+
+        W16(ep, fen_taddrh, 0);
+        W16(ep, fen_taddrm, 0);
+        W16(ep, fen_taddrl, 0);
+
+        W16(ep, fen_maxd1, 1520);       /* maximum DMA1 length */
+        W16(ep, fen_maxd2, 1520);       /* maximum DMA2 length */
+
+        /* Clear stat counters, in case we ever enable RMON */
+        W32(ep, fen_octc, 0);
+        W32(ep, fen_colc, 0);
+        W32(ep, fen_broc, 0);
+        W32(ep, fen_mulc, 0);
+        W32(ep, fen_uspc, 0);
+        W32(ep, fen_frgc, 0);
+        W32(ep, fen_ospc, 0);
+        W32(ep, fen_jbrc, 0);
+        W32(ep, fen_p64c, 0);
+        W32(ep, fen_p65c, 0);
+        W32(ep, fen_p128c, 0);
+        W32(ep, fen_p256c, 0);
+        W32(ep, fen_p512c, 0);
+        W32(ep, fen_p1024c, 0);
+
+        W16(ep, fen_rfthr, 0);  /* Suggested by manual */
+        W16(ep, fen_rfcnt, 0);
+        W16(ep, fen_cftype, 0);
+
+        fs_init_bds(dev);
+
+        /* adjust to speed (for RMII mode) */
+        if (fpi->use_rmii) {
+                if (fep->speed == 100)
+                        C8(fcccp, fcc_gfemr, 0x20);
+                else
+                        S8(fcccp, fcc_gfemr, 0x20);
+        }
+
+        fcc_cr_cmd(fep, 0x0c, CPM_CR_INIT_TRX);
+
+        /* clear events */
+        W16(fccp, fcc_fcce, 0xffff);
+
+        /* Enable interrupts we wish to service */
+        W16(fccp, fcc_fccm, FCC_ENET_TXE | FCC_ENET_RXF | FCC_ENET_TXB);
+
+        /* Set GFMR to enable Ethernet operating mode */
+        W32(fccp, fcc_gfmr, FCC_GFMR_TCI | FCC_GFMR_MODE_ENET);
+
+        /* set sync/delimiters */
+        W16(fccp, fcc_fdsr, 0xd555);
+
+        W32(fccp, fcc_fpsmr, FCC_PSMR_ENCRC);
+
+        if (fpi->use_rmii)
+                S32(fccp, fcc_fpsmr, FCC_PSMR_RMII);
+
+        /* adjust to duplex mode */
+        if (fep->duplex)
+                S32(fccp, fcc_fpsmr, FCC_PSMR_FDE | FCC_PSMR_LPB);
+        else
+                C32(fccp, fcc_fpsmr, FCC_PSMR_FDE | FCC_PSMR_LPB);
+
+        S32(fccp, fcc_gfmr, FCC_GFMR_ENR | FCC_GFMR_ENT);
+}
+
+static void stop(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        /* stop ethernet */
+        C32(fccp, fcc_gfmr, FCC_GFMR_ENR | FCC_GFMR_ENT);
+
+        /* clear events */
+        W16(fccp, fcc_fcce, 0xffff);
+
+        /* clear interrupt mask */
+        W16(fccp, fcc_fccm, 0);
+
+        fs_cleanup_bds(dev);
+}
+
+static void pre_request_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void post_free_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void napi_clear_rx_event(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        W16(fccp, fcc_fcce, FCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_enable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        S16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_disable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        C16(fccp, fcc_fccm, FCC_NAPI_RX_EVENT_MSK);
+}
+
+static void rx_bd_done(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void tx_kickstart(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static u32 get_int_events(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        return (u32)R16(fccp, fcc_fcce);
+}
+
+static void clear_int_events(struct net_device *dev, u32 int_events)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        W16(fccp, fcc_fcce, int_events & 0xffff);
+}
+
+static void ev_error(struct net_device *dev, u32 int_events)
+{
+        printk(KERN_WARNING DRV_MODULE_NAME
+               ": %s FS_ENET ERROR(s) 0x%x\n", dev->name, int_events);
+}
+
+int get_regs(struct net_device *dev, void *p, int *sizep)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (*sizep < sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t))
+                return -EINVAL;
+
+        memcpy_fromio(p, fep->fcc.fccp, sizeof(fcc_t));
+        p = (char *)p + sizeof(fcc_t);
+
+        memcpy_fromio(p, fep->fcc.fcccp, sizeof(fcc_c_t));
+        p = (char *)p + sizeof(fcc_c_t);
+
+        memcpy_fromio(p, fep->fcc.ep, sizeof(fcc_enet_t));
+
+        return 0;
+}
+
+int get_regs_len(struct net_device *dev)
+{
+        return sizeof(fcc_t) + sizeof(fcc_c_t) + sizeof(fcc_enet_t);
+}
+
+/* Some transmit errors cause the transmitter to shut
+ * down.  We now issue a restart transmit.  Since the
+ * errors close the BD and update the pointers, the restart
+ * _should_ pick up without having to reset any of our
+ * pointers either.  Also, To workaround 8260 device erratum 
+ * CPM37, we must disable and then re-enable the transmitter
+ * following a Late Collision, Underrun, or Retry Limit error.
+ */
+void tx_restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fcc_t *fccp = fep->fcc.fccp;
+
+        C32(fccp, fcc_gfmr, FCC_GFMR_ENT);
+        udelay(10);
+        S32(fccp, fcc_gfmr, FCC_GFMR_ENT);
+
+        fcc_cr_cmd(fep, 0x0C, CPM_CR_RESTART_TX);
+}
+
+/*************************************************************************/
+
+const struct fs_ops fs_fcc_ops = {
+        .setup_data             = setup_data,
+        .cleanup_data           = cleanup_data,
+        .set_multicast_list     = set_multicast_list,
+        .restart                = restart,
+        .stop                   = stop,
+        .pre_request_irq        = pre_request_irq,
+        .post_free_irq          = post_free_irq,
+        .napi_clear_rx_event    = napi_clear_rx_event,
+        .napi_enable_rx         = napi_enable_rx,
+        .napi_disable_rx        = napi_disable_rx,
+        .rx_bd_done             = rx_bd_done,
+        .tx_kickstart           = tx_kickstart,
+        .get_int_events         = get_int_events,
+        .clear_int_events       = clear_int_events,
+        .ev_error               = ev_error,
+        .get_regs               = get_regs,
+        .get_regs_len           = get_regs_len,
+        .tx_restart             = tx_restart,
+        .allocate_bd            = allocate_bd,
+        .free_bd                = free_bd,
+};
diff --git a/drivers/net/fs_enet/mac-fec.c b/drivers/net/fs_enet/mac-fec.c
new file mode 100644
index 000000000000..5ef4e845a387
--- /dev/null
+++ b/drivers/net/fs_enet/mac-fec.c
@@ -0,0 +1,653 @@
+/*
+ * Freescale Ethernet controllers
+ *
+ * Copyright (c) 2005 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ *
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#ifdef CONFIG_8xx
+#include <asm/8xx_immap.h>
+#include <asm/pgtable.h>
+#include <asm/mpc8xx.h>
+#include <asm/commproc.h>
+#endif
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+#if defined(CONFIG_CPM1)
+/* for a CPM1 __raw_xxx's are sufficient */
+#define __fs_out32(addr, x)     __raw_writel(x, addr)
+#define __fs_out16(addr, x)     __raw_writew(x, addr)
+#define __fs_in32(addr) __raw_readl(addr)
+#define __fs_in16(addr) __raw_readw(addr)
+#else
+/* for others play it safe */
+#define __fs_out32(addr, x)     out_be32(addr, x)
+#define __fs_out16(addr, x)     out_be16(addr, x)
+#define __fs_in32(addr) in_be32(addr)
+#define __fs_in16(addr) in_be16(addr)
+#endif
+
+/* write */
+#define FW(_fecp, _reg, _v) __fs_out32(&(_fecp)->fec_ ## _reg, (_v))
+
+/* read */
+#define FR(_fecp, _reg) __fs_in32(&(_fecp)->fec_ ## _reg)
+
+/* set bits */
+#define FS(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) | (_v))
+
+/* clear bits */
+#define FC(_fecp, _reg, _v) FW(_fecp, _reg, FR(_fecp, _reg) & ~(_v))
+
+
+/* CRC polynomium used by the FEC for the multicast group filtering */
+#define FEC_CRC_POLY   0x04C11DB7
+
+#define FEC_MAX_MULTICAST_ADDRS 64
+
+/* Interrupt events/masks.
+*/
+#define FEC_ENET_HBERR  0x80000000U     /* Heartbeat error          */
+#define FEC_ENET_BABR   0x40000000U     /* Babbling receiver        */
+#define FEC_ENET_BABT   0x20000000U     /* Babbling transmitter     */
+#define FEC_ENET_GRA    0x10000000U     /* Graceful stop complete   */
+#define FEC_ENET_TXF    0x08000000U     /* Full frame transmitted   */
+#define FEC_ENET_TXB    0x04000000U     /* A buffer was transmitted */
+#define FEC_ENET_RXF    0x02000000U     /* Full frame received      */
+#define FEC_ENET_RXB    0x01000000U     /* A buffer was received    */
+#define FEC_ENET_MII    0x00800000U     /* MII interrupt            */
+#define FEC_ENET_EBERR  0x00400000U     /* SDMA bus error           */
+
+#define FEC_ECNTRL_PINMUX       0x00000004
+#define FEC_ECNTRL_ETHER_EN     0x00000002
+#define FEC_ECNTRL_RESET        0x00000001
+
+#define FEC_RCNTRL_BC_REJ       0x00000010
+#define FEC_RCNTRL_PROM         0x00000008
+#define FEC_RCNTRL_MII_MODE     0x00000004
+#define FEC_RCNTRL_DRT          0x00000002
+#define FEC_RCNTRL_LOOP         0x00000001
+
+#define FEC_TCNTRL_FDEN         0x00000004
+#define FEC_TCNTRL_HBC          0x00000002
+#define FEC_TCNTRL_GTS          0x00000001
+
+
+/* Make MII read/write commands for the FEC.
+*/
+#define mk_mii_read(REG)        (0x60020000 | ((REG & 0x1f) << 18))
+#define mk_mii_write(REG, VAL)  (0x50020000 | ((REG & 0x1f) << 18) | (VAL & 0xffff))
+#define mk_mii_end              0
+
+#define FEC_MII_LOOPS   10000
+
+/*
+ * Delay to wait for FEC reset command to complete (in us) 
+ */
+#define FEC_RESET_DELAY         50
+
+static int whack_reset(fec_t * fecp)
+{
+        int i;
+
+        FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET);
+        for (i = 0; i < FEC_RESET_DELAY; i++) {
+                if ((FR(fecp, ecntrl) & FEC_ECNTRL_RESET) == 0)
+                        return 0;       /* OK */
+                udelay(1);
+        }
+
+        return -1;
+}
+
+static int do_pd_setup(struct fs_enet_private *fep)
+{
+        struct platform_device *pdev = to_platform_device(fep->dev); 
+        struct resource *r;
+        
+        /* Fill out IRQ field */
+        fep->interrupt = platform_get_irq_byname(pdev,"interrupt");
+        
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
+        fep->fec.fecp =(void*)r->start;
+
+        if(fep->fec.fecp == NULL)
+                return -EINVAL;
+
+        return 0;
+        
+}
+
+#define FEC_NAPI_RX_EVENT_MSK   (FEC_ENET_RXF | FEC_ENET_RXB)
+#define FEC_RX_EVENT            (FEC_ENET_RXF)
+#define FEC_TX_EVENT            (FEC_ENET_TXF)
+#define FEC_ERR_EVENT_MSK       (FEC_ENET_HBERR | FEC_ENET_BABR | \
+                                 FEC_ENET_BABT | FEC_ENET_EBERR)
+
+static int setup_data(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (do_pd_setup(fep) != 0)
+                return -EINVAL;
+
+        fep->fec.hthi = 0;
+        fep->fec.htlo = 0;
+
+        fep->ev_napi_rx = FEC_NAPI_RX_EVENT_MSK;
+        fep->ev_rx = FEC_RX_EVENT;
+        fep->ev_tx = FEC_TX_EVENT;
+        fep->ev_err = FEC_ERR_EVENT_MSK;
+
+        return 0;
+}
+
+static int allocate_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+        
+        fep->ring_base = dma_alloc_coherent(fep->dev,
+                                            (fpi->tx_ring + fpi->rx_ring) *
+                                            sizeof(cbd_t), &fep->ring_mem_addr,
+                                            GFP_KERNEL);
+        if (fep->ring_base == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void free_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        if(fep->ring_base)
+                dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring)
+                                        * sizeof(cbd_t),
+                                        fep->ring_base,
+                                        fep->ring_mem_addr);
+}
+
+static void cleanup_data(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void set_promiscuous_mode(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FS(fecp, r_cntrl, FEC_RCNTRL_PROM);
+}
+
+static void set_multicast_start(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        fep->fec.hthi = 0;
+        fep->fec.htlo = 0;
+}
+
+static void set_multicast_one(struct net_device *dev, const u8 *mac)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        int temp, hash_index, i, j;
+        u32 crc, csrVal;
+        u8 byte, msb;
+
+        crc = 0xffffffff;
+        for (i = 0; i < 6; i++) {
+                byte = mac[i];
+                for (j = 0; j < 8; j++) {
+                        msb = crc >> 31;
+                        crc <<= 1;
+                        if (msb ^ (byte & 0x1))
+                                crc ^= FEC_CRC_POLY;
+                        byte >>= 1;
+                }
+        }
+
+        temp = (crc & 0x3f) >> 1;
+        hash_index = ((temp & 0x01) << 4) |
+                     ((temp & 0x02) << 2) |
+                     ((temp & 0x04)) |
+                     ((temp & 0x08) >> 2) |
+                     ((temp & 0x10) >> 4);
+        csrVal = 1 << hash_index;
+        if (crc & 1)
+                fep->fec.hthi |= csrVal;
+        else
+                fep->fec.htlo |= csrVal;
+}
+
+static void set_multicast_finish(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        /* if all multi or too many multicasts; just enable all */
+        if ((dev->flags & IFF_ALLMULTI) != 0 ||
+            dev->mc_count > FEC_MAX_MULTICAST_ADDRS) {
+                fep->fec.hthi = 0xffffffffU;
+                fep->fec.htlo = 0xffffffffU;
+        }
+
+        FC(fecp, r_cntrl, FEC_RCNTRL_PROM);
+        FW(fecp, hash_table_high, fep->fec.hthi);
+        FW(fecp, hash_table_low, fep->fec.htlo);
+}
+
+static void set_multicast_list(struct net_device *dev)
+{
+        struct dev_mc_list *pmc;
+
+        if ((dev->flags & IFF_PROMISC) == 0) {
+                set_multicast_start(dev);
+                for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next)
+                        set_multicast_one(dev, pmc->dmi_addr);
+                set_multicast_finish(dev);
+        } else
+                set_promiscuous_mode(dev);
+}
+
+static void restart(struct net_device *dev)
+{
+#ifdef CONFIG_DUET
+        immap_t *immap = fs_enet_immap;
+        u32 cptr;
+#endif
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+        const struct fs_platform_info *fpi = fep->fpi;
+        dma_addr_t rx_bd_base_phys, tx_bd_base_phys;
+        int r;
+        u32 addrhi, addrlo;
+
+        r = whack_reset(fep->fec.fecp);
+        if (r != 0)
+                printk(KERN_ERR DRV_MODULE_NAME
+                                ": %s FEC Reset FAILED!\n", dev->name);
+
+        /*
+         * Set station address. 
+         */
+        addrhi = ((u32) dev->dev_addr[0] << 24) |
+                 ((u32) dev->dev_addr[1] << 16) |
+                 ((u32) dev->dev_addr[2] <<  8) |
+                  (u32) dev->dev_addr[3];
+        addrlo = ((u32) dev->dev_addr[4] << 24) |
+                 ((u32) dev->dev_addr[5] << 16);
+        FW(fecp, addr_low, addrhi);
+        FW(fecp, addr_high, addrlo);
+
+        /*
+         * Reset all multicast. 
+         */
+        FW(fecp, hash_table_high, fep->fec.hthi);
+        FW(fecp, hash_table_low, fep->fec.htlo);
+
+        /*
+         * Set maximum receive buffer size. 
+         */
+        FW(fecp, r_buff_size, PKT_MAXBLR_SIZE);
+        FW(fecp, r_hash, PKT_MAXBUF_SIZE);
+
+        /* get physical address */
+        rx_bd_base_phys = fep->ring_mem_addr;
+        tx_bd_base_phys = rx_bd_base_phys + sizeof(cbd_t) * fpi->rx_ring;
+
+        /*
+         * Set receive and transmit descriptor base. 
+         */
+        FW(fecp, r_des_start, rx_bd_base_phys);
+        FW(fecp, x_des_start, tx_bd_base_phys);
+
+        fs_init_bds(dev);
+
+        /*
+         * Enable big endian and don't care about SDMA FC. 
+         */
+        FW(fecp, fun_code, 0x78000000);
+
+        /*
+         * Set MII speed. 
+         */
+        FW(fecp, mii_speed, fep->mii_bus->fec.mii_speed);
+
+        /*
+         * Clear any outstanding interrupt. 
+         */
+        FW(fecp, ievent, 0xffc0);
+        FW(fecp, ivec, (fep->interrupt / 2) << 29);
+        
+
+        /*
+         * adjust to speed (only for DUET & RMII) 
+         */
+#ifdef CONFIG_DUET
+        if (fpi->use_rmii) {
+                cptr = in_be32(&immap->im_cpm.cp_cptr);
+                switch (fs_get_fec_index(fpi->fs_no)) {
+                case 0:
+                        cptr |= 0x100;
+                        if (fep->speed == 10)
+                                cptr |= 0x0000010;
+                        else if (fep->speed == 100)
+                                cptr &= ~0x0000010;
+                        break;
+                case 1:
+                        cptr |= 0x80;
+                        if (fep->speed == 10)
+                                cptr |= 0x0000008;
+                        else if (fep->speed == 100)
+                                cptr &= ~0x0000008;
+                        break;
+                default:
+                        BUG();  /* should never happen */
+                        break;
+                }
+                out_be32(&immap->im_cpm.cp_cptr, cptr);
+        }
+#endif
+
+        FW(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
+        /*
+         * adjust to duplex mode 
+         */
+        if (fep->duplex) {
+                FC(fecp, r_cntrl, FEC_RCNTRL_DRT);
+                FS(fecp, x_cntrl, FEC_TCNTRL_FDEN);     /* FD enable */
+        } else {
+                FS(fecp, r_cntrl, FEC_RCNTRL_DRT);
+                FC(fecp, x_cntrl, FEC_TCNTRL_FDEN);     /* FD disable */
+        }
+
+        /*
+         * Enable interrupts we wish to service. 
+         */
+        FW(fecp, imask, FEC_ENET_TXF | FEC_ENET_TXB |
+           FEC_ENET_RXF | FEC_ENET_RXB);
+
+        /*
+         * And last, enable the transmit and receive processing. 
+         */
+        FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
+        FW(fecp, r_des_active, 0x01000000);
+}
+
+static void stop(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+        struct fs_enet_mii_bus *bus = fep->mii_bus;
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+        int i;
+
+        if ((FR(fecp, ecntrl) & FEC_ECNTRL_ETHER_EN) == 0)
+                return;         /* already down */
+
+        FW(fecp, x_cntrl, 0x01);        /* Graceful transmit stop */
+        for (i = 0; ((FR(fecp, ievent) & 0x10000000) == 0) &&
+             i < FEC_RESET_DELAY; i++)
+                udelay(1);
+
+        if (i == FEC_RESET_DELAY)
+                printk(KERN_WARNING DRV_MODULE_NAME
+                       ": %s FEC timeout on graceful transmit stop\n",
+                       dev->name);
+        /*
+         * Disable FEC. Let only MII interrupts. 
+         */
+        FW(fecp, imask, 0);
+        FC(fecp, ecntrl, FEC_ECNTRL_ETHER_EN);
+
+        fs_cleanup_bds(dev);
+
+        /* shut down FEC1? that's where the mii bus is */
+        if (fep->fec.idx == 0 && bus->refs > 1 && bi->method == fsmii_fec) {
+                FS(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
+                FS(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
+                FW(fecp, ievent, FEC_ENET_MII);
+                FW(fecp, mii_speed, bus->fec.mii_speed);
+        }
+}
+
+static void pre_request_irq(struct net_device *dev, int irq)
+{
+        immap_t *immap = fs_enet_immap;
+        u32 siel;
+
+        /* SIU interrupt */
+        if (irq >= SIU_IRQ0 && irq < SIU_LEVEL7) {
+
+                siel = in_be32(&immap->im_siu_conf.sc_siel);
+                if ((irq & 1) == 0)
+                        siel |= (0x80000000 >> irq);
+                else
+                        siel &= ~(0x80000000 >> (irq & ~1));
+                out_be32(&immap->im_siu_conf.sc_siel, siel);
+        }
+}
+
+static void post_free_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void napi_clear_rx_event(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, ievent, FEC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_enable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FS(fecp, imask, FEC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_disable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FC(fecp, imask, FEC_NAPI_RX_EVENT_MSK);
+}
+
+static void rx_bd_done(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, r_des_active, 0x01000000);
+}
+
+static void tx_kickstart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, x_des_active, 0x01000000);
+}
+
+static u32 get_int_events(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        return FR(fecp, ievent) & FR(fecp, imask);
+}
+
+static void clear_int_events(struct net_device *dev, u32 int_events)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        fec_t *fecp = fep->fec.fecp;
+
+        FW(fecp, ievent, int_events);
+}
+
+static void ev_error(struct net_device *dev, u32 int_events)
+{
+        printk(KERN_WARNING DRV_MODULE_NAME
+               ": %s FEC ERROR(s) 0x%x\n", dev->name, int_events);
+}
+
+int get_regs(struct net_device *dev, void *p, int *sizep)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (*sizep < sizeof(fec_t))
+                return -EINVAL;
+
+        memcpy_fromio(p, fep->fec.fecp, sizeof(fec_t));
+
+        return 0;
+}
+
+int get_regs_len(struct net_device *dev)
+{
+        return sizeof(fec_t);
+}
+
+void tx_restart(struct net_device *dev)
+{
+        /* nothing */
+}
+
+/*************************************************************************/
+
+const struct fs_ops fs_fec_ops = {
+        .setup_data             = setup_data,
+        .cleanup_data           = cleanup_data,
+        .set_multicast_list     = set_multicast_list,
+        .restart                = restart,
+        .stop                   = stop,
+        .pre_request_irq        = pre_request_irq,
+        .post_free_irq          = post_free_irq,
+        .napi_clear_rx_event    = napi_clear_rx_event,
+        .napi_enable_rx         = napi_enable_rx,
+        .napi_disable_rx        = napi_disable_rx,
+        .rx_bd_done             = rx_bd_done,
+        .tx_kickstart           = tx_kickstart,
+        .get_int_events         = get_int_events,
+        .clear_int_events       = clear_int_events,
+        .ev_error               = ev_error,
+        .get_regs               = get_regs,
+        .get_regs_len           = get_regs_len,
+        .tx_restart             = tx_restart,
+        .allocate_bd            = allocate_bd,
+        .free_bd                = free_bd,
+};
+
+/***********************************************************************/
+
+static int mii_read(struct fs_enet_mii_bus *bus, int phy_id, int location)
+{
+        fec_t *fecp = bus->fec.fecp;
+        int i, ret = -1;
+
+        if ((FR(fecp, r_cntrl) & FEC_RCNTRL_MII_MODE) == 0)
+                BUG();
+
+        /* Add PHY address to register command.  */
+        FW(fecp, mii_data, (phy_id << 23) | mk_mii_read(location));
+
+        for (i = 0; i < FEC_MII_LOOPS; i++)
+                if ((FR(fecp, ievent) & FEC_ENET_MII) != 0)
+                        break;
+
+        if (i < FEC_MII_LOOPS) {
+                FW(fecp, ievent, FEC_ENET_MII);
+                ret = FR(fecp, mii_data) & 0xffff;
+        }
+
+        return ret;
+}
+
+static void mii_write(struct fs_enet_mii_bus *bus, int phy_id, int location, int value)
+{
+        fec_t *fecp = bus->fec.fecp;
+        int i;
+
+        /* this must never happen */
+        if ((FR(fecp, r_cntrl) & FEC_RCNTRL_MII_MODE) == 0)
+                BUG();
+
+        /* Add PHY address to register command.  */
+        FW(fecp, mii_data, (phy_id << 23) | mk_mii_write(location, value));
+
+        for (i = 0; i < FEC_MII_LOOPS; i++)
+                if ((FR(fecp, ievent) & FEC_ENET_MII) != 0)
+                        break;
+
+        if (i < FEC_MII_LOOPS)
+                FW(fecp, ievent, FEC_ENET_MII);
+}
+
+int fs_mii_fec_init(struct fs_enet_mii_bus *bus)
+{
+        bd_t *bd = (bd_t *)__res;
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+        fec_t *fecp;
+
+        if (bi->id != 0)
+                return -1;
+
+        bus->fec.fecp = &((immap_t *)fs_enet_immap)->im_cpm.cp_fec;
+        bus->fec.mii_speed = ((((bd->bi_intfreq + 4999999) / 2500000) / 2)
+                                & 0x3F) << 1;
+
+        fecp = bus->fec.fecp;
+
+        FS(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
+        FS(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
+        FW(fecp, ievent, FEC_ENET_MII);
+        FW(fecp, mii_speed, bus->fec.mii_speed);
+
+        bus->mii_read = mii_read;
+        bus->mii_write = mii_write;
+
+        return 0;
+}
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
new file mode 100644
index 000000000000..d8c6e9cadcf5
--- /dev/null
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -0,0 +1,524 @@
+/*
+ * Ethernet on Serial Communications Controller (SCC) driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#ifdef CONFIG_8xx
+#include <asm/8xx_immap.h>
+#include <asm/pgtable.h>
+#include <asm/mpc8xx.h>
+#include <asm/commproc.h>
+#endif
+
+#include "fs_enet.h"
+
+/*************************************************/
+
+#if defined(CONFIG_CPM1)
+/* for a 8xx __raw_xxx's are sufficient */
+#define __fs_out32(addr, x)     __raw_writel(x, addr)
+#define __fs_out16(addr, x)     __raw_writew(x, addr)
+#define __fs_out8(addr, x)      __raw_writeb(x, addr)
+#define __fs_in32(addr) __raw_readl(addr)
+#define __fs_in16(addr) __raw_readw(addr)
+#define __fs_in8(addr)  __raw_readb(addr)
+#else
+/* for others play it safe */
+#define __fs_out32(addr, x)     out_be32(addr, x)
+#define __fs_out16(addr, x)     out_be16(addr, x)
+#define __fs_in32(addr) in_be32(addr)
+#define __fs_in16(addr) in_be16(addr)
+#endif
+
+/* write, read, set bits, clear bits */
+#define W32(_p, _m, _v) __fs_out32(&(_p)->_m, (_v))
+#define R32(_p, _m)     __fs_in32(&(_p)->_m)
+#define S32(_p, _m, _v) W32(_p, _m, R32(_p, _m) | (_v))
+#define C32(_p, _m, _v) W32(_p, _m, R32(_p, _m) & ~(_v))
+
+#define W16(_p, _m, _v) __fs_out16(&(_p)->_m, (_v))
+#define R16(_p, _m)     __fs_in16(&(_p)->_m)
+#define S16(_p, _m, _v) W16(_p, _m, R16(_p, _m) | (_v))
+#define C16(_p, _m, _v) W16(_p, _m, R16(_p, _m) & ~(_v))
+
+#define W8(_p, _m, _v)  __fs_out8(&(_p)->_m, (_v))
+#define R8(_p, _m)      __fs_in8(&(_p)->_m)
+#define S8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) | (_v))
+#define C8(_p, _m, _v)  W8(_p, _m, R8(_p, _m) & ~(_v))
+
+#define SCC_MAX_MULTICAST_ADDRS 64
+
+/*
+ * Delay to wait for SCC reset command to complete (in us) 
+ */
+#define SCC_RESET_DELAY         50
+#define MAX_CR_CMD_LOOPS        10000
+
+static inline int scc_cr_cmd(struct fs_enet_private *fep, u32 op)
+{
+        cpm8xx_t *cpmp = &((immap_t *)fs_enet_immap)->im_cpm;
+        u32 v, ch;
+        int i = 0;
+
+        ch = fep->scc.idx << 2;
+        v = mk_cr_cmd(ch, op);
+        W16(cpmp, cp_cpcr, v | CPM_CR_FLG);
+        for (i = 0; i < MAX_CR_CMD_LOOPS; i++)
+                if ((R16(cpmp, cp_cpcr) & CPM_CR_FLG) == 0)
+                        break;
+
+        if (i >= MAX_CR_CMD_LOOPS) {
+                printk(KERN_ERR "%s(): Not able to issue CPM command\n",
+                        __FUNCTION__);
+                return 1;
+        }
+        return 0;
+}
+
+static int do_pd_setup(struct fs_enet_private *fep)
+{
+        struct platform_device *pdev = to_platform_device(fep->dev);
+        struct resource *r;
+
+        /* Fill out IRQ field */
+        fep->interrupt = platform_get_irq_byname(pdev, "interrupt");
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
+        fep->scc.sccp = (void *)r->start;
+
+        if (fep->scc.sccp == NULL)
+                return -EINVAL;
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pram");
+        fep->scc.ep = (void *)r->start;
+
+        if (fep->scc.ep == NULL)
+                return -EINVAL;
+
+        return 0;
+}
+
+#define SCC_NAPI_RX_EVENT_MSK   (SCCE_ENET_RXF | SCCE_ENET_RXB)
+#define SCC_RX_EVENT            (SCCE_ENET_RXF)
+#define SCC_TX_EVENT            (SCCE_ENET_TXB)
+#define SCC_ERR_EVENT_MSK       (SCCE_ENET_TXE | SCCE_ENET_BSY)
+
+static int setup_data(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->scc.idx = fs_get_scc_index(fpi->fs_no);
+        if ((unsigned int)fep->fcc.idx > 4)     /* max 4 SCCs */
+                return -EINVAL;
+
+        do_pd_setup(fep);
+
+        fep->scc.hthi = 0;
+        fep->scc.htlo = 0;
+
+        fep->ev_napi_rx = SCC_NAPI_RX_EVENT_MSK;
+        fep->ev_rx = SCC_RX_EVENT;
+        fep->ev_tx = SCC_TX_EVENT;
+        fep->ev_err = SCC_ERR_EVENT_MSK;
+
+        return 0;
+}
+
+static int allocate_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        const struct fs_platform_info *fpi = fep->fpi;
+
+        fep->ring_mem_addr = cpm_dpalloc((fpi->tx_ring + fpi->rx_ring) *
+                                         sizeof(cbd_t), 8);
+        if (IS_DPERR(fep->ring_mem_addr))
+                return -ENOMEM;
+
+        fep->ring_base = cpm_dpram_addr(fep->ring_mem_addr);
+
+        return 0;
+}
+
+static void free_bd(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (fep->ring_base)
+                cpm_dpfree(fep->ring_mem_addr);
+}
+
+static void cleanup_data(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void set_promiscuous_mode(struct net_device *dev)
+{                               
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        S16(sccp, scc_psmr, SCC_PSMR_PRO);
+}
+
+static void set_multicast_start(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_enet_t *ep = fep->scc.ep;
+
+        W16(ep, sen_gaddr1, 0);
+        W16(ep, sen_gaddr2, 0);
+        W16(ep, sen_gaddr3, 0);
+        W16(ep, sen_gaddr4, 0);
+}
+
+static void set_multicast_one(struct net_device *dev, const u8 * mac)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_enet_t *ep = fep->scc.ep;
+        u16 taddrh, taddrm, taddrl;
+
+        taddrh = ((u16) mac[5] << 8) | mac[4];
+        taddrm = ((u16) mac[3] << 8) | mac[2];
+        taddrl = ((u16) mac[1] << 8) | mac[0];
+
+        W16(ep, sen_taddrh, taddrh);
+        W16(ep, sen_taddrm, taddrm);
+        W16(ep, sen_taddrl, taddrl);
+        scc_cr_cmd(fep, CPM_CR_SET_GADDR);
+}
+
+static void set_multicast_finish(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+        scc_enet_t *ep = fep->scc.ep;
+
+        /* clear promiscuous always */
+        C16(sccp, scc_psmr, SCC_PSMR_PRO);
+
+        /* if all multi or too many multicasts; just enable all */
+        if ((dev->flags & IFF_ALLMULTI) != 0 ||
+            dev->mc_count > SCC_MAX_MULTICAST_ADDRS) {
+
+                W16(ep, sen_gaddr1, 0xffff);
+                W16(ep, sen_gaddr2, 0xffff);
+                W16(ep, sen_gaddr3, 0xffff);
+                W16(ep, sen_gaddr4, 0xffff);
+        }
+}
+
+static void set_multicast_list(struct net_device *dev)
+{
+        struct dev_mc_list *pmc;
+
+        if ((dev->flags & IFF_PROMISC) == 0) {
+                set_multicast_start(dev);
+                for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next)
+                        set_multicast_one(dev, pmc->dmi_addr);
+                set_multicast_finish(dev);
+        } else
+                set_promiscuous_mode(dev);
+}
+
+/*
+ * This function is called to start or restart the FEC during a link
+ * change.  This only happens when switching between half and full
+ * duplex.
+ */
+static void restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+        scc_enet_t *ep = fep->scc.ep;
+        const struct fs_platform_info *fpi = fep->fpi;
+        u16 paddrh, paddrm, paddrl;
+        const unsigned char *mac;
+        int i;
+
+        C32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
+
+        /* clear everything (slow & steady does it) */
+        for (i = 0; i < sizeof(*ep); i++)
+                __fs_out8((char *)ep + i, 0);
+
+        /* point to bds */
+        W16(ep, sen_genscc.scc_rbase, fep->ring_mem_addr);
+        W16(ep, sen_genscc.scc_tbase,
+            fep->ring_mem_addr + sizeof(cbd_t) * fpi->rx_ring);
+
+        /* Initialize function code registers for big-endian.
+         */
+        W8(ep, sen_genscc.scc_rfcr, SCC_EB);
+        W8(ep, sen_genscc.scc_tfcr, SCC_EB);
+
+        /* Set maximum bytes per receive buffer.
+         * This appears to be an Ethernet frame size, not the buffer
+         * fragment size.  It must be a multiple of four.
+         */
+        W16(ep, sen_genscc.scc_mrblr, 0x5f0);
+
+        /* Set CRC preset and mask.
+         */
+        W32(ep, sen_cpres, 0xffffffff);
+        W32(ep, sen_cmask, 0xdebb20e3);
+
+        W32(ep, sen_crcec, 0);  /* CRC Error counter */
+        W32(ep, sen_alec, 0);   /* alignment error counter */
+        W32(ep, sen_disfc, 0);  /* discard frame counter */
+
+        W16(ep, sen_pads, 0x8888);      /* Tx short frame pad character */
+        W16(ep, sen_retlim, 15);        /* Retry limit threshold */
+
+        W16(ep, sen_maxflr, 0x5ee);     /* maximum frame length register */
+
+        W16(ep, sen_minflr, PKT_MINBUF_SIZE);   /* minimum frame length register */
+
+        W16(ep, sen_maxd1, 0x000005f0); /* maximum DMA1 length */
+        W16(ep, sen_maxd2, 0x000005f0); /* maximum DMA2 length */
+
+        /* Clear hash tables.
+         */
+        W16(ep, sen_gaddr1, 0);
+        W16(ep, sen_gaddr2, 0);
+        W16(ep, sen_gaddr3, 0);
+        W16(ep, sen_gaddr4, 0);
+        W16(ep, sen_iaddr1, 0);
+        W16(ep, sen_iaddr2, 0);
+        W16(ep, sen_iaddr3, 0);
+        W16(ep, sen_iaddr4, 0);
+
+        /* set address 
+         */
+        mac = dev->dev_addr;
+        paddrh = ((u16) mac[5] << 8) | mac[4];
+        paddrm = ((u16) mac[3] << 8) | mac[2];
+        paddrl = ((u16) mac[1] << 8) | mac[0];
+
+        W16(ep, sen_paddrh, paddrh);
+        W16(ep, sen_paddrm, paddrm);
+        W16(ep, sen_paddrl, paddrl);
+
+        W16(ep, sen_pper, 0);
+        W16(ep, sen_taddrl, 0);
+        W16(ep, sen_taddrm, 0);
+        W16(ep, sen_taddrh, 0);
+
+        fs_init_bds(dev);
+
+        scc_cr_cmd(fep, CPM_CR_INIT_TRX);
+
+        W16(sccp, scc_scce, 0xffff);
+
+        /* Enable interrupts we wish to service. 
+         */
+        W16(sccp, scc_sccm, SCCE_ENET_TXE | SCCE_ENET_RXF | SCCE_ENET_TXB);
+
+        /* Set GSMR_H to enable all normal operating modes.
+         * Set GSMR_L to enable Ethernet to MC68160.
+         */
+        W32(sccp, scc_gsmrh, 0);
+        W32(sccp, scc_gsmrl,
+            SCC_GSMRL_TCI | SCC_GSMRL_TPL_48 | SCC_GSMRL_TPP_10 |
+            SCC_GSMRL_MODE_ENET);
+
+        /* Set sync/delimiters.
+         */
+        W16(sccp, scc_dsr, 0xd555);
+
+        /* Set processing mode.  Use Ethernet CRC, catch broadcast, and
+         * start frame search 22 bit times after RENA.
+         */
+        W16(sccp, scc_psmr, SCC_PSMR_ENCRC | SCC_PSMR_NIB22);
+
+        /* Set full duplex mode if needed */
+        if (fep->duplex)
+                S16(sccp, scc_psmr, SCC_PSMR_LPB | SCC_PSMR_FDE);
+
+        S32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
+}
+
+static void stop(struct net_device *dev)        
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+        int i;
+
+        for (i = 0; (R16(sccp, scc_sccm) == 0) && i < SCC_RESET_DELAY; i++)
+                udelay(1);
+
+        if (i == SCC_RESET_DELAY)
+                printk(KERN_WARNING DRV_MODULE_NAME
+                       ": %s SCC timeout on graceful transmit stop\n",
+                       dev->name);
+
+        W16(sccp, scc_sccm, 0);
+        C32(sccp, scc_gsmrl, SCC_GSMRL_ENR | SCC_GSMRL_ENT);
+
+        fs_cleanup_bds(dev);
+}
+
+static void pre_request_irq(struct net_device *dev, int irq)
+{
+        immap_t *immap = fs_enet_immap;
+        u32 siel;
+
+        /* SIU interrupt */
+        if (irq >= SIU_IRQ0 && irq < SIU_LEVEL7) {
+
+                siel = in_be32(&immap->im_siu_conf.sc_siel);
+                if ((irq & 1) == 0)
+                        siel |= (0x80000000 >> irq);
+                else
+                        siel &= ~(0x80000000 >> (irq & ~1));
+                out_be32(&immap->im_siu_conf.sc_siel, siel);
+        }
+}
+
+static void post_free_irq(struct net_device *dev, int irq)
+{
+        /* nothing */
+}
+
+static void napi_clear_rx_event(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        W16(sccp, scc_scce, SCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_enable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        S16(sccp, scc_sccm, SCC_NAPI_RX_EVENT_MSK);
+}
+
+static void napi_disable_rx(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        C16(sccp, scc_sccm, SCC_NAPI_RX_EVENT_MSK);
+}
+
+static void rx_bd_done(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static void tx_kickstart(struct net_device *dev)
+{
+        /* nothing */
+}
+
+static u32 get_int_events(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        return (u32) R16(sccp, scc_scce);
+}
+
+static void clear_int_events(struct net_device *dev, u32 int_events)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+        scc_t *sccp = fep->scc.sccp;
+
+        W16(sccp, scc_scce, int_events & 0xffff);
+}
+
+static void ev_error(struct net_device *dev, u32 int_events)
+{
+        printk(KERN_WARNING DRV_MODULE_NAME
+               ": %s SCC ERROR(s) 0x%x\n", dev->name, int_events);
+}
+
+static int get_regs(struct net_device *dev, void *p, int *sizep)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        if (*sizep < sizeof(scc_t) + sizeof(scc_enet_t))
+                return -EINVAL;
+
+        memcpy_fromio(p, fep->scc.sccp, sizeof(scc_t));
+        p = (char *)p + sizeof(scc_t);
+
+        memcpy_fromio(p, fep->scc.ep, sizeof(scc_enet_t));
+
+        return 0;
+}
+
+static int get_regs_len(struct net_device *dev)
+{
+        return sizeof(scc_t) + sizeof(scc_enet_t);
+}
+
+static void tx_restart(struct net_device *dev)
+{
+        struct fs_enet_private *fep = netdev_priv(dev);
+
+        scc_cr_cmd(fep, CPM_CR_RESTART_TX);
+}
+
+/*************************************************************************/
+
+const struct fs_ops fs_scc_ops = {
+        .setup_data             = setup_data,
+        .cleanup_data           = cleanup_data,
+        .set_multicast_list     = set_multicast_list,
+        .restart                = restart,
+        .stop                   = stop,
+        .pre_request_irq        = pre_request_irq,
+        .post_free_irq          = post_free_irq,
+        .napi_clear_rx_event    = napi_clear_rx_event,
+        .napi_enable_rx         = napi_enable_rx,
+        .napi_disable_rx        = napi_disable_rx,
+        .rx_bd_done             = rx_bd_done,
+        .tx_kickstart           = tx_kickstart,
+        .get_int_events         = get_int_events,
+        .clear_int_events       = clear_int_events,
+        .ev_error               = ev_error,
+        .get_regs               = get_regs,
+        .get_regs_len           = get_regs_len,
+        .tx_restart             = tx_restart,
+        .allocate_bd            = allocate_bd,
+        .free_bd                = free_bd,
+};
diff --git a/drivers/net/fs_enet/mii-bitbang.c b/drivers/net/fs_enet/mii-bitbang.c
new file mode 100644
index 000000000000..24a5e2e23d18
--- /dev/null
+++ b/drivers/net/fs_enet/mii-bitbang.c
@@ -0,0 +1,405 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+#ifdef CONFIG_8xx
+static int bitbang_prep_bit(u8 **dirp, u8 **datp, u8 *mskp, int port, int bit)
+{
+        immap_t *im = (immap_t *)fs_enet_immap;
+        void *dir, *dat, *ppar;
+        int adv;
+        u8 msk;
+
+        switch (port) {
+                case fsiop_porta:
+                        dir = &im->im_ioport.iop_padir;
+                        dat = &im->im_ioport.iop_padat;
+                        ppar = &im->im_ioport.iop_papar;
+                        break;
+
+                case fsiop_portb:
+                        dir = &im->im_cpm.cp_pbdir;
+                        dat = &im->im_cpm.cp_pbdat;
+                        ppar = &im->im_cpm.cp_pbpar;
+                        break;
+
+                case fsiop_portc:
+                        dir = &im->im_ioport.iop_pcdir;
+                        dat = &im->im_ioport.iop_pcdat;
+                        ppar = &im->im_ioport.iop_pcpar;
+                        break;
+
+                case fsiop_portd:
+                        dir = &im->im_ioport.iop_pddir;
+                        dat = &im->im_ioport.iop_pddat;
+                        ppar = &im->im_ioport.iop_pdpar;
+                        break;
+
+                case fsiop_porte:
+                        dir = &im->im_cpm.cp_pedir;
+                        dat = &im->im_cpm.cp_pedat;
+                        ppar = &im->im_cpm.cp_pepar;
+                        break;
+
+                default:
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               "Illegal port value %d!\n", port);
+                        return -EINVAL;
+        }
+
+        adv = bit >> 3;
+        dir = (char *)dir + adv;
+        dat = (char *)dat + adv;
+        ppar = (char *)ppar + adv;
+
+        msk = 1 << (7 - (bit & 7));
+        if ((in_8(ppar) & msk) != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       "pin %d on port %d is not general purpose!\n", bit, port);
+                return -EINVAL;
+        }
+
+        *dirp = dir;
+        *datp = dat;
+        *mskp = msk;
+
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_8260
+static int bitbang_prep_bit(u8 **dirp, u8 **datp, u8 *mskp, int port, int bit)
+{
+        iop_cpm2_t *io = &((cpm2_map_t *)fs_enet_immap)->im_ioport;
+        void *dir, *dat, *ppar;
+        int adv;
+        u8 msk;
+
+        switch (port) {
+                case fsiop_porta:
+                        dir = &io->iop_pdira;
+                        dat = &io->iop_pdata;
+                        ppar = &io->iop_ppara;
+                        break;
+
+                case fsiop_portb:
+                        dir = &io->iop_pdirb;
+                        dat = &io->iop_pdatb;
+                        ppar = &io->iop_pparb;
+                        break;
+
+                case fsiop_portc:
+                        dir = &io->iop_pdirc;
+                        dat = &io->iop_pdatc;
+                        ppar = &io->iop_pparc;
+                        break;
+
+                case fsiop_portd:
+                        dir = &io->iop_pdird;
+                        dat = &io->iop_pdatd;
+                        ppar = &io->iop_ppard;
+                        break;
+
+                default:
+                        printk(KERN_ERR DRV_MODULE_NAME
+                               "Illegal port value %d!\n", port);
+                        return -EINVAL;
+        }
+
+        adv = bit >> 3;
+        dir = (char *)dir + adv;
+        dat = (char *)dat + adv;
+        ppar = (char *)ppar + adv;
+
+        msk = 1 << (7 - (bit & 7));
+        if ((in_8(ppar) & msk) != 0) {
+                printk(KERN_ERR DRV_MODULE_NAME
+                       "pin %d on port %d is not general purpose!\n", bit, port);
+                return -EINVAL;
+        }
+
+        *dirp = dir;
+        *datp = dat;
+        *mskp = msk;
+
+        return 0;
+}
+#endif
+
+static inline void bb_set(u8 *p, u8 m)
+{
+        out_8(p, in_8(p) | m);
+}
+
+static inline void bb_clr(u8 *p, u8 m)
+{
+        out_8(p, in_8(p) & ~m);
+}
+
+static inline int bb_read(u8 *p, u8 m)
+{
+        return (in_8(p) & m) != 0;
+}
+
+static inline void mdio_active(struct fs_enet_mii_bus *bus)
+{
+        bb_set(bus->bitbang.mdio_dir, bus->bitbang.mdio_msk);
+}
+
+static inline void mdio_tristate(struct fs_enet_mii_bus *bus)
+{
+        bb_clr(bus->bitbang.mdio_dir, bus->bitbang.mdio_msk);
+}
+
+static inline int mdio_read(struct fs_enet_mii_bus *bus)
+{
+        return bb_read(bus->bitbang.mdio_dat, bus->bitbang.mdio_msk);
+}
+
+static inline void mdio(struct fs_enet_mii_bus *bus, int what)
+{
+        if (what)
+                bb_set(bus->bitbang.mdio_dat, bus->bitbang.mdio_msk);
+        else
+                bb_clr(bus->bitbang.mdio_dat, bus->bitbang.mdio_msk);
+}
+
+static inline void mdc(struct fs_enet_mii_bus *bus, int what)
+{
+        if (what)
+                bb_set(bus->bitbang.mdc_dat, bus->bitbang.mdc_msk);
+        else
+                bb_clr(bus->bitbang.mdc_dat, bus->bitbang.mdc_msk);
+}
+
+static inline void mii_delay(struct fs_enet_mii_bus *bus)
+{
+        udelay(bus->bus_info->i.bitbang.delay);
+}
+
+/* Utility to send the preamble, address, and register (common to read and write). */
+static void bitbang_pre(struct fs_enet_mii_bus *bus, int read, u8 addr, u8 reg)
+{
+        int j;
+
+        /*
+         * Send a 32 bit preamble ('1's) with an extra '1' bit for good measure.
+         * The IEEE spec says this is a PHY optional requirement.  The AMD
+         * 79C874 requires one after power up and one after a MII communications
+         * error.  This means that we are doing more preambles than we need,
+         * but it is safer and will be much more robust.
+         */
+
+        mdio_active(bus);
+        mdio(bus, 1);
+        for (j = 0; j < 32; j++) {
+                mdc(bus, 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+        }
+
+        /* send the start bit (01) and the read opcode (10) or write (10) */
+        mdc(bus, 0);
+        mdio(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, read);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, !read);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        /* send the PHY address */
+        for (j = 0; j < 5; j++) {
+                mdc(bus, 0);
+                mdio(bus, (addr & 0x10) != 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+                addr <<= 1;
+        }
+
+        /* send the register address */
+        for (j = 0; j < 5; j++) {
+                mdc(bus, 0);
+                mdio(bus, (reg & 0x10) != 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+                reg <<= 1;
+        }
+}
+
+static int mii_read(struct fs_enet_mii_bus *bus, int phy_id, int location)
+{
+        u16 rdreg;
+        int ret, j;
+        u8 addr = phy_id & 0xff;
+        u8 reg = location & 0xff;
+
+        bitbang_pre(bus, 1, addr, reg);
+
+        /* tri-state our MDIO I/O pin so we can read */
+        mdc(bus, 0);
+        mdio_tristate(bus);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        /* check the turnaround bit: the PHY should be driving it to zero */
+        if (mdio_read(bus) != 0) {
+                /* PHY didn't drive TA low */
+                for (j = 0; j < 32; j++) {
+                        mdc(bus, 0);
+                        mii_delay(bus);
+                        mdc(bus, 1);
+                        mii_delay(bus);
+                }
+                ret = -1;
+                goto out;
+        }
+
+        mdc(bus, 0);
+        mii_delay(bus);
+
+        /* read 16 bits of register data, MSB first */
+        rdreg = 0;
+        for (j = 0; j < 16; j++) {
+                mdc(bus, 1);
+                mii_delay(bus);
+                rdreg <<= 1;
+                rdreg |= mdio_read(bus);
+                mdc(bus, 0);
+                mii_delay(bus);
+        }
+
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        ret = rdreg;
+out:
+        return ret;
+}
+
+static void mii_write(struct fs_enet_mii_bus *bus, int phy_id, int location, int val)
+{
+        int j;
+        u8 addr = phy_id & 0xff;
+        u8 reg = location & 0xff;
+        u16 value = val & 0xffff;
+
+        bitbang_pre(bus, 0, addr, reg);
+
+        /* send the turnaround (10) */
+        mdc(bus, 0);
+        mdio(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+        mdc(bus, 0);
+        mdio(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+
+        /* write 16 bits of register data, MSB first */
+        for (j = 0; j < 16; j++) {
+                mdc(bus, 0);
+                mdio(bus, (value & 0x8000) != 0);
+                mii_delay(bus);
+                mdc(bus, 1);
+                mii_delay(bus);
+                value <<= 1;
+        }
+
+        /*
+         * Tri-state the MDIO line.
+         */
+        mdio_tristate(bus);
+        mdc(bus, 0);
+        mii_delay(bus);
+        mdc(bus, 1);
+        mii_delay(bus);
+}
+
+int fs_mii_bitbang_init(struct fs_enet_mii_bus *bus)
+{
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+        int r;
+
+        r = bitbang_prep_bit(&bus->bitbang.mdio_dir,
+                         &bus->bitbang.mdio_dat,
+                         &bus->bitbang.mdio_msk,
+                         bi->i.bitbang.mdio_port,
+                         bi->i.bitbang.mdio_bit);
+        if (r != 0)
+                return r;
+
+        r = bitbang_prep_bit(&bus->bitbang.mdc_dir,
+                         &bus->bitbang.mdc_dat,
+                         &bus->bitbang.mdc_msk,
+                         bi->i.bitbang.mdc_port,
+                         bi->i.bitbang.mdc_bit);
+        if (r != 0)
+                return r;
+
+        bus->mii_read = mii_read;
+        bus->mii_write = mii_write;
+
+        return 0;
+}
diff --git a/drivers/net/fs_enet/mii-fixed.c b/drivers/net/fs_enet/mii-fixed.c
new file mode 100644
index 000000000000..b3e192d612e5
--- /dev/null
+++ b/drivers/net/fs_enet/mii-fixed.c
@@ -0,0 +1,92 @@
+/*
+ * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
+ *
+ * Copyright (c) 2003 Intracom S.A. 
+ *  by Pantelis Antoniou <panto@intracom.gr>
+ * 
+ * 2005 (c) MontaVista Software, Inc. 
+ * Vitaly Bordug <vbordug@ru.mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License 
+ * version 2. This program is licensed "as is" without any warranty of any 
+ * kind, whether express or implied.
+ */
+
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/bitops.h>
+
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+#include "fs_enet.h"
+
+static const u16 mii_regs[7] = {
+        0x3100,
+        0x786d,
+        0x0fff,
+        0x0fff,
+        0x01e1,
+        0x45e1,
+        0x0003,
+};
+
+static int mii_read(struct fs_enet_mii_bus *bus, int phy_id, int location)
+{
+        int ret = 0;
+
+        if ((unsigned int)location >= ARRAY_SIZE(mii_regs))
+                return -1;
+
+        if (location != 5)
+                ret = mii_regs[location];
+        else
+                ret = bus->fixed.lpa;
+
+        return ret;
+}
+
+static void mii_write(struct fs_enet_mii_bus *bus, int phy_id, int location, int val)
+{
+        /* do nothing */
+}
+
+int fs_mii_fixed_init(struct fs_enet_mii_bus *bus)
+{
+        const struct fs_mii_bus_info *bi = bus->bus_info;
+
+        bus->fixed.lpa = 0x45e1;        /* default 100Mb, full duplex */
+
+        /* if speed is fixed at 10Mb, remove 100Mb modes */
+        if (bi->i.fixed.speed == 10)
+                bus->fixed.lpa &= ~LPA_100;
+
+        /* if duplex is half, remove full duplex modes */
+        if (bi->i.fixed.duplex == 0)
+                bus->fixed.lpa &= ~LPA_DUPLEX;
+
+        bus->mii_read = mii_read;
+        bus->mii_write = mii_write;
+
+        return 0;
+}
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index 85d6dc005be0..3e9accf137e7 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -390,10 +390,8 @@ static void ax_changedmtu(struct mkiss *ax)
                        "MTU change cancelled.\n",
                        ax->dev->name);
                 dev->mtu = ax->mtu;
-                if (xbuff != NULL)
-                        kfree(xbuff);
-                if (rbuff != NULL)
-                        kfree(rbuff);
+                kfree(xbuff);
+                kfree(rbuff);
                 return;
         }
 
diff --git a/drivers/net/ibm_emac/Makefile b/drivers/net/ibm_emac/Makefile
index 7f583a333c24..f98ddf0e807a 100644
--- a/drivers/net/ibm_emac/Makefile
+++ b/drivers/net/ibm_emac/Makefile
@@ -1,12 +1,11 @@
 #
-# Makefile for the IBM PPC4xx EMAC controllers
+# Makefile for the PowerPC 4xx on-chip ethernet driver
 #
 
 obj-$(CONFIG_IBM_EMAC) += ibm_emac.o
 
-ibm_emac-objs := ibm_emac_mal.o ibm_emac_core.o ibm_emac_phy.o
-
-# Only need this if you want to see additional debug messages
-ifeq ($(CONFIG_IBM_EMAC_ERRMSG), y)
-ibm_emac-objs += ibm_emac_debug.o
-endif
+ibm_emac-objs := ibm_emac_mal.o ibm_emac_core.o ibm_emac_phy.o 
+ibm_emac-$(CONFIG_IBM_EMAC_ZMII) += ibm_emac_zmii.o
+ibm_emac-$(CONFIG_IBM_EMAC_RGMII) += ibm_emac_rgmii.o
+ibm_emac-$(CONFIG_IBM_EMAC_TAH) += ibm_emac_tah.o
+ibm_emac-$(CONFIG_IBM_EMAC_DEBUG) += ibm_emac_debug.o
diff --git a/drivers/net/ibm_emac/ibm_emac.h b/drivers/net/ibm_emac/ibm_emac.h
index 15d5a0e82862..28c476f28c20 100644
--- a/drivers/net/ibm_emac/ibm_emac.h
+++ b/drivers/net/ibm_emac/ibm_emac.h
@@ -1,110 +1,142 @@
 /*
- * ibm_emac.h
+ * drivers/net/ibm_emac/ibm_emac.h
  *
+ * Register definitions for PowerPC 4xx on-chip ethernet contoller
  *
- *      Armin Kuster akuster@mvista.com
- *      June, 2002
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- * Copyright 2002 MontaVista Softare Inc.
+ * Based on original work by
+ *      Matt Porter <mporter@kernel.crashing.org>
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2002-2004 MontaVista Software Inc.
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
  * Free Software Foundation;  either version 2 of the  License, or (at your
  * option) any later version.
+ *
  */
+#ifndef __IBM_EMAC_H_
+#define __IBM_EMAC_H_
+
+#include <linux/config.h>
+#include <linux/types.h>
+
+/* This is a simple check to prevent use of this driver on non-tested SoCs */
+#if !defined(CONFIG_405GP) && !defined(CONFIG_405GPR) && !defined(CONFIG_405EP) && \
+    !defined(CONFIG_440GP) && !defined(CONFIG_440GX) && !defined(CONFIG_440SP) && \
+    !defined(CONFIG_440EP) && !defined(CONFIG_NP405H)
+#error  "Unknown SoC. Please, check chip user manual and make sure EMAC defines are OK"
+#endif
+
+/* EMAC registers               Write Access rules */
+struct emac_regs {
+        u32 mr0;                /* special      */
+        u32 mr1;                /* Reset        */
+        u32 tmr0;               /* special      */
+        u32 tmr1;               /* special      */
+        u32 rmr;                /* Reset        */
+        u32 isr;                /* Always       */
+        u32 iser;               /* Reset        */
+        u32 iahr;               /* Reset, R, T  */
+        u32 ialr;               /* Reset, R, T  */
+        u32 vtpid;              /* Reset, R, T  */
+        u32 vtci;               /* Reset, R, T  */
+        u32 ptr;                /* Reset,    T  */
+        u32 iaht1;              /* Reset, R     */
+        u32 iaht2;              /* Reset, R     */
+        u32 iaht3;              /* Reset, R     */
+        u32 iaht4;              /* Reset, R     */
+        u32 gaht1;              /* Reset, R     */
+        u32 gaht2;              /* Reset, R     */
+        u32 gaht3;              /* Reset, R     */
+        u32 gaht4;              /* Reset, R     */
+        u32 lsah;
+        u32 lsal;
+        u32 ipgvr;              /* Reset,    T  */
+        u32 stacr;              /* special      */
+        u32 trtr;               /* special      */
+        u32 rwmr;               /* Reset        */
+        u32 octx;
+        u32 ocrx;
+        u32 ipcr;
+};
+
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_ETHTOOL_REGS_VER           0
+#define EMAC_ETHTOOL_REGS_SIZE          (sizeof(struct emac_regs) - sizeof(u32))
+#else
+#define EMAC_ETHTOOL_REGS_VER           1
+#define EMAC_ETHTOOL_REGS_SIZE          sizeof(struct emac_regs)
+#endif
 
-#ifndef _IBM_EMAC_H_
-#define _IBM_EMAC_H_
-/* General defines needed for the driver */
+/* EMACx_MR0 */
+#define EMAC_MR0_RXI                    0x80000000
+#define EMAC_MR0_TXI                    0x40000000
+#define EMAC_MR0_SRST                   0x20000000
+#define EMAC_MR0_TXE                    0x10000000
+#define EMAC_MR0_RXE                    0x08000000
+#define EMAC_MR0_WKE                    0x04000000
 
-/* Emac */
-typedef struct emac_regs {
-        u32 em0mr0;
-        u32 em0mr1;
-        u32 em0tmr0;
-        u32 em0tmr1;
-        u32 em0rmr;
-        u32 em0isr;
-        u32 em0iser;
-        u32 em0iahr;
-        u32 em0ialr;
-        u32 em0vtpid;
-        u32 em0vtci;
-        u32 em0ptr;
-        u32 em0iaht1;
-        u32 em0iaht2;
-        u32 em0iaht3;
-        u32 em0iaht4;
-        u32 em0gaht1;
-        u32 em0gaht2;
-        u32 em0gaht3;
-        u32 em0gaht4;
-        u32 em0lsah;
-        u32 em0lsal;
-        u32 em0ipgvr;
-        u32 em0stacr;
-        u32 em0trtr;
-        u32 em0rwmr;
-} emac_t;
+/* EMACx_MR1 */
+#define EMAC_MR1_FDE                    0x80000000
+#define EMAC_MR1_ILE                    0x40000000
+#define EMAC_MR1_VLE                    0x20000000
+#define EMAC_MR1_EIFC                   0x10000000
+#define EMAC_MR1_APP                    0x08000000
+#define EMAC_MR1_IST                    0x01000000
 
-/* MODE REG 0 */
-#define EMAC_M0_RXI                     0x80000000
-#define EMAC_M0_TXI                     0x40000000
-#define EMAC_M0_SRST                    0x20000000
-#define EMAC_M0_TXE                     0x10000000
-#define EMAC_M0_RXE                     0x08000000
-#define EMAC_M0_WKE                     0x04000000
+#define EMAC_MR1_MF_MASK                0x00c00000
+#define EMAC_MR1_MF_10                  0x00000000
+#define EMAC_MR1_MF_100                 0x00400000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_MR1_MF_1000                0x00000000
+#define EMAC_MR1_MF_1000GPCS            0x00000000
+#define EMAC_MR1_MF_IPPA(id)            0x00000000
+#else
+#define EMAC_MR1_MF_1000                0x00800000
+#define EMAC_MR1_MF_1000GPCS            0x00c00000
+#define EMAC_MR1_MF_IPPA(id)            (((id) & 0x1f) << 6)
+#endif
 
-/* MODE Reg 1 */
-#define EMAC_M1_FDE                     0x80000000
-#define EMAC_M1_ILE                     0x40000000
-#define EMAC_M1_VLE                     0x20000000
-#define EMAC_M1_EIFC                    0x10000000
-#define EMAC_M1_APP                     0x08000000
-#define EMAC_M1_AEMI                    0x02000000
-#define EMAC_M1_IST                     0x01000000
-#define EMAC_M1_MF_1000GPCS             0x00c00000      /* Internal GPCS */
-#define EMAC_M1_MF_1000MBPS             0x00800000      /* External GPCS */
-#define EMAC_M1_MF_100MBPS              0x00400000
-#define EMAC_M1_RFS_16K                 0x00280000      /* 000 for 512 byte */
-#define EMAC_M1_TR                      0x00008000
-#ifdef CONFIG_IBM_EMAC4
-#define EMAC_M1_RFS_8K                  0x00200000
-#define EMAC_M1_RFS_4K                  0x00180000
-#define EMAC_M1_RFS_2K                  0x00100000
-#define EMAC_M1_RFS_1K                  0x00080000
-#define EMAC_M1_TX_FIFO_16K             0x00050000      /* 0's for 512 byte */
-#define EMAC_M1_TX_FIFO_8K              0x00040000
-#define EMAC_M1_TX_FIFO_4K              0x00030000
-#define EMAC_M1_TX_FIFO_2K              0x00020000
-#define EMAC_M1_TX_FIFO_1K              0x00010000
-#define EMAC_M1_TX_TR                   0x00008000
-#define EMAC_M1_TX_MWSW                 0x00001000      /* 0 wait for status */
-#define EMAC_M1_JUMBO_ENABLE            0x00000800      /* Upt to 9Kr status */
-#define EMAC_M1_OPB_CLK_66              0x00000008      /* 66Mhz */
-#define EMAC_M1_OPB_CLK_83              0x00000010      /* 83Mhz */
-#define EMAC_M1_OPB_CLK_100             0x00000018      /* 100Mhz */
-#define EMAC_M1_OPB_CLK_100P            0x00000020      /* 100Mhz+ */
-#else                           /* CONFIG_IBM_EMAC4 */
-#define EMAC_M1_RFS_4K                  0x00300000      /* ~4k for 512 byte */
-#define EMAC_M1_RFS_2K                  0x00200000
-#define EMAC_M1_RFS_1K                  0x00100000
-#define EMAC_M1_TX_FIFO_2K              0x00080000      /* 0's for 512 byte */
-#define EMAC_M1_TX_FIFO_1K              0x00040000
-#define EMAC_M1_TR0_DEPEND              0x00010000      /* 0'x for single packet */
-#define EMAC_M1_TR1_DEPEND              0x00004000
-#define EMAC_M1_TR1_MULTI               0x00002000
-#define EMAC_M1_JUMBO_ENABLE            0x00001000
-#endif                          /* CONFIG_IBM_EMAC4 */
-#define EMAC_M1_BASE                    (EMAC_M1_TX_FIFO_2K | \
-                                        EMAC_M1_APP | \
-                                        EMAC_M1_TR | EMAC_M1_VLE)
+#define EMAC_TX_FIFO_SIZE               2048
 
-/* Transmit Mode Register 0 */
-#define EMAC_TMR0_GNP0                  0x80000000
-#define EMAC_TMR0_GNP1                  0x40000000
-#define EMAC_TMR0_GNPD                  0x20000000
-#define EMAC_TMR0_FC                    0x10000000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_MR1_RFS_4K                 0x00300000
+#define EMAC_MR1_RFS_16K                0x00000000
+#define EMAC_RX_FIFO_SIZE(gige)         4096
+#define EMAC_MR1_TFS_2K                 0x00080000
+#define EMAC_MR1_TR0_MULT               0x00008000
+#define EMAC_MR1_JPSM                   0x00000000
+#define EMAC_MR1_BASE(opb)              (EMAC_MR1_TFS_2K | EMAC_MR1_TR0_MULT)
+#else
+#define EMAC_MR1_RFS_4K                 0x00180000
+#define EMAC_MR1_RFS_16K                0x00280000
+#define EMAC_RX_FIFO_SIZE(gige)         ((gige) ? 16384 : 4096)
+#define EMAC_MR1_TFS_2K                 0x00020000
+#define EMAC_MR1_TR                     0x00008000
+#define EMAC_MR1_MWSW_001               0x00001000
+#define EMAC_MR1_JPSM                   0x00000800
+#define EMAC_MR1_OBCI_MASK              0x00000038
+#define EMAC_MR1_OBCI_50                0x00000000
+#define EMAC_MR1_OBCI_66                0x00000008
+#define EMAC_MR1_OBCI_83                0x00000010
+#define EMAC_MR1_OBCI_100               0x00000018
+#define EMAC_MR1_OBCI_100P              0x00000020
+#define EMAC_MR1_OBCI(freq)             ((freq) <= 50  ? EMAC_MR1_OBCI_50 : \
+                                         (freq) <= 66  ? EMAC_MR1_OBCI_66 : \
+                                         (freq) <= 83  ? EMAC_MR1_OBCI_83 : \
+                                         (freq) <= 100 ? EMAC_MR1_OBCI_100 : EMAC_MR1_OBCI_100P)
+#define EMAC_MR1_BASE(opb)              (EMAC_MR1_TFS_2K | EMAC_MR1_TR | \
+                                         EMAC_MR1_MWSW_001 | EMAC_MR1_OBCI(opb))
+#endif
+
+/* EMACx_TMR0 */
+#define EMAC_TMR0_GNP                   0x80000000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_TMR0_DEFAULT               0x00000000      
+#else
 #define EMAC_TMR0_TFAE_2_32             0x00000001
 #define EMAC_TMR0_TFAE_4_64             0x00000002
 #define EMAC_TMR0_TFAE_8_128            0x00000003
@@ -112,14 +144,36 @@ typedef struct emac_regs {
 #define EMAC_TMR0_TFAE_32_512           0x00000005
 #define EMAC_TMR0_TFAE_64_1024          0x00000006
 #define EMAC_TMR0_TFAE_128_2048         0x00000007
+#define EMAC_TMR0_DEFAULT               EMAC_TMR0_TFAE_2_32
+#endif
+#define EMAC_TMR0_XMIT                  (EMAC_TMR0_GNP | EMAC_TMR0_DEFAULT)
+
+/* EMACx_TMR1 */
+
+/* IBM manuals are not very clear here. 
+ * This is my interpretation of how things are. --ebs
+ */
+#if defined(CONFIG_40x)
+#define EMAC_FIFO_ENTRY_SIZE            8
+#define EMAC_MAL_BURST_SIZE             (16 * 4)
+#else
+#define EMAC_FIFO_ENTRY_SIZE            16
+#define EMAC_MAL_BURST_SIZE             (64 * 4)
+#endif
+
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_TMR1(l,h)                  (((l) << 27) | (((h) & 0xff) << 16))
+#else
+#define EMAC_TMR1(l,h)                  (((l) << 27) | (((h) & 0x3ff) << 14))
+#endif
 
-/* Receive Mode Register */
+/* EMACx_RMR */
 #define EMAC_RMR_SP                     0x80000000
 #define EMAC_RMR_SFCS                   0x40000000
-#define EMAC_RMR_ARRP                   0x20000000
-#define EMAC_RMR_ARP                    0x10000000
-#define EMAC_RMR_AROP                   0x08000000
-#define EMAC_RMR_ARPI                   0x04000000
+#define EMAC_RMR_RRP                    0x20000000
+#define EMAC_RMR_RFP                    0x10000000
+#define EMAC_RMR_ROP                    0x08000000
+#define EMAC_RMR_RPIR                   0x04000000
 #define EMAC_RMR_PPP                    0x02000000
 #define EMAC_RMR_PME                    0x01000000
 #define EMAC_RMR_PMME                   0x00800000
@@ -127,6 +181,9 @@ typedef struct emac_regs {
 #define EMAC_RMR_MIAE                   0x00200000
 #define EMAC_RMR_BAE                    0x00100000
 #define EMAC_RMR_MAE                    0x00080000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_RMR_BASE                   0x00000000
+#else
 #define EMAC_RMR_RFAF_2_32              0x00000001
 #define EMAC_RMR_RFAF_4_64              0x00000002
 #define EMAC_RMR_RFAF_8_128             0x00000003
@@ -134,9 +191,21 @@ typedef struct emac_regs {
 #define EMAC_RMR_RFAF_32_512            0x00000005
 #define EMAC_RMR_RFAF_64_1024           0x00000006
 #define EMAC_RMR_RFAF_128_2048          0x00000007
-#define EMAC_RMR_BASE                   (EMAC_RMR_IAE | EMAC_RMR_BAE)
+#define EMAC_RMR_BASE                   EMAC_RMR_RFAF_128_2048
+#endif
 
-/* Interrupt Status & enable Regs */
+/* EMACx_ISR & EMACx_ISER */
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_ISR_TXPE                   0x00000000
+#define EMAC_ISR_RXPE                   0x00000000
+#define EMAC_ISR_TXUE                   0x00000000
+#define EMAC_ISR_RXOE                   0x00000000
+#else
+#define EMAC_ISR_TXPE                   0x20000000
+#define EMAC_ISR_RXPE                   0x10000000
+#define EMAC_ISR_TXUE                   0x08000000
+#define EMAC_ISR_RXOE                   0x04000000
+#endif
 #define EMAC_ISR_OVR                    0x02000000
 #define EMAC_ISR_PP                     0x01000000
 #define EMAC_ISR_BP                     0x00800000
@@ -147,53 +216,62 @@ typedef struct emac_regs {
 #define EMAC_ISR_PTLE                   0x00040000
 #define EMAC_ISR_ORE                    0x00020000
 #define EMAC_ISR_IRE                    0x00010000
-#define EMAC_ISR_DBDM                   0x00000200
-#define EMAC_ISR_DB0                    0x00000100
-#define EMAC_ISR_SE0                    0x00000080
-#define EMAC_ISR_TE0                    0x00000040
-#define EMAC_ISR_DB1                    0x00000020
-#define EMAC_ISR_SE1                    0x00000010
-#define EMAC_ISR_TE1                    0x00000008
+#define EMAC_ISR_SQE                    0x00000080
+#define EMAC_ISR_TE                     0x00000040
 #define EMAC_ISR_MOS                    0x00000002
 #define EMAC_ISR_MOF                    0x00000001
 
-/* STA CONTROL REG */
+/* EMACx_STACR */
+#define EMAC_STACR_PHYD_MASK            0xffff
+#define EMAC_STACR_PHYD_SHIFT           16
 #define EMAC_STACR_OC                   0x00008000
 #define EMAC_STACR_PHYE                 0x00004000
-#define EMAC_STACR_WRITE                0x00002000
-#define EMAC_STACR_READ                 0x00001000
-#define EMAC_STACR_CLK_83MHZ            0x00000800      /* 0's for 50Mhz */
-#define EMAC_STACR_CLK_66MHZ            0x00000400
-#define EMAC_STACR_CLK_100MHZ           0x00000C00
+#define EMAC_STACR_STAC_MASK            0x00003000
+#define EMAC_STACR_STAC_READ            0x00001000
+#define EMAC_STACR_STAC_WRITE           0x00002000
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_STACR_OPBC_MASK            0x00000C00
+#define EMAC_STACR_OPBC_50              0x00000000
+#define EMAC_STACR_OPBC_66              0x00000400
+#define EMAC_STACR_OPBC_83              0x00000800
+#define EMAC_STACR_OPBC_100             0x00000C00
+#define EMAC_STACR_OPBC(freq)           ((freq) <= 50 ? EMAC_STACR_OPBC_50 : \
+                                         (freq) <= 66 ? EMAC_STACR_OPBC_66 : \
+                                         (freq) <= 83 ? EMAC_STACR_OPBC_83 : EMAC_STACR_OPBC_100)
+#define EMAC_STACR_BASE(opb)            EMAC_STACR_OPBC(opb)
+#else
+#define EMAC_STACR_BASE(opb)            0x00000000
+#endif
+#define EMAC_STACR_PCDA_MASK            0x1f
+#define EMAC_STACR_PCDA_SHIFT           5
+#define EMAC_STACR_PRA_MASK             0x1f
+
+/* EMACx_TRTR */
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_TRTR_SHIFT                 27
+#else
+#define EMAC_TRTR_SHIFT                 24
+#endif
+#define EMAC_TRTR(size)                 ((((size) >> 6) - 1) << EMAC_TRTR_SHIFT)
 
-/* Transmit Request Threshold Register */
-#define EMAC_TRTR_1600                  0x18000000      /* 0's for 64 Bytes */
-#define EMAC_TRTR_1024                  0x0f000000
-#define EMAC_TRTR_512                   0x07000000
-#define EMAC_TRTR_256                   0x03000000
-#define EMAC_TRTR_192                   0x10000000
-#define EMAC_TRTR_128                   0x01000000
+/* EMACx_RWMR */
+#if !defined(CONFIG_IBM_EMAC4)
+#define EMAC_RWMR(l,h)                  (((l) << 23) | ( ((h) & 0x1ff) << 7))   
+#else
+#define EMAC_RWMR(l,h)                  (((l) << 22) | ( ((h) & 0x3ff) << 6))   
+#endif
 
+/* EMAC specific TX descriptor control fields (write access) */
 #define EMAC_TX_CTRL_GFCS               0x0200
 #define EMAC_TX_CTRL_GP                 0x0100
 #define EMAC_TX_CTRL_ISA                0x0080
 #define EMAC_TX_CTRL_RSA                0x0040
 #define EMAC_TX_CTRL_IVT                0x0020
 #define EMAC_TX_CTRL_RVT                0x0010
-#define EMAC_TX_CTRL_TAH_CSUM           0x000e  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG4           0x000a  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG3           0x0008  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG2           0x0006  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG1           0x0004  /* TAH only */
-#define EMAC_TX_CTRL_TAH_SEG0           0x0002  /* TAH only */
-#define EMAC_TX_CTRL_TAH_DIS            0x0000  /* TAH only */
+#define EMAC_TX_CTRL_TAH_CSUM           0x000e
 
-#define EMAC_TX_CTRL_DFLT ( \
-        MAL_TX_CTRL_INTR | EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP )
-
-/* madmal transmit status / Control bits */
+/* EMAC specific TX descriptor status fields (read access) */
 #define EMAC_TX_ST_BFCS                 0x0200
-#define EMAC_TX_ST_BPP                  0x0100
 #define EMAC_TX_ST_LCS                  0x0080
 #define EMAC_TX_ST_ED                   0x0040
 #define EMAC_TX_ST_EC                   0x0020
@@ -202,8 +280,16 @@ typedef struct emac_regs {
 #define EMAC_TX_ST_SC                   0x0004
 #define EMAC_TX_ST_UR                   0x0002
 #define EMAC_TX_ST_SQE                  0x0001
+#if !defined(CONFIG_IBM_EMAC_TAH)
+#define EMAC_IS_BAD_TX(v)               ((v) & (EMAC_TX_ST_LCS | EMAC_TX_ST_ED | \
+                                         EMAC_TX_ST_EC | EMAC_TX_ST_LC | \
+                                         EMAC_TX_ST_MC | EMAC_TX_ST_UR))
+#else
+#define EMAC_IS_BAD_TX(v)               ((v) & (EMAC_TX_ST_LCS | EMAC_TX_ST_ED | \
+                                         EMAC_TX_ST_EC | EMAC_TX_ST_LC))
+#endif                                   
 
-/* madmal receive status / Control bits */
+/* EMAC specific RX descriptor status fields (read access) */
 #define EMAC_RX_ST_OE                   0x0200
 #define EMAC_RX_ST_PP                   0x0100
 #define EMAC_RX_ST_BP                   0x0080
@@ -214,54 +300,10 @@ typedef struct emac_regs {
 #define EMAC_RX_ST_PTL                  0x0004
 #define EMAC_RX_ST_ORE                  0x0002
 #define EMAC_RX_ST_IRE                  0x0001
-#define EMAC_BAD_RX_PACKET              0x02ff
-#define EMAC_CSUM_VER_ERROR             0x0003
-
-/* identify a bad rx packet dependent on emac features */
-#ifdef CONFIG_IBM_EMAC4
-#define EMAC_IS_BAD_RX_PACKET(desc) \
-        (((desc & (EMAC_BAD_RX_PACKET & ~EMAC_CSUM_VER_ERROR)) || \
-        ((desc & EMAC_CSUM_VER_ERROR) == EMAC_RX_ST_ORE) || \
-        ((desc & EMAC_CSUM_VER_ERROR) == EMAC_RX_ST_IRE)))
-#else
-#define EMAC_IS_BAD_RX_PACKET(desc) \
-         (desc & EMAC_BAD_RX_PACKET)
-#endif
-
-/* SoC implementation specific EMAC register defaults */
-#if defined(CONFIG_440GP)
-#define EMAC_RWMR_DEFAULT               0x80009000
-#define EMAC_TMR0_DEFAULT               0x00000000
-#define EMAC_TMR1_DEFAULT               0xf8640000
-#elif defined(CONFIG_440GX)
-#define EMAC_RWMR_DEFAULT               0x1000a200
-#define EMAC_TMR0_DEFAULT               EMAC_TMR0_TFAE_2_32
-#define EMAC_TMR1_DEFAULT               0xa00f0000
-#elif defined(CONFIG_440SP)
-#define EMAC_RWMR_DEFAULT               0x08002000
-#define EMAC_TMR0_DEFAULT               EMAC_TMR0_TFAE_128_2048
-#define EMAC_TMR1_DEFAULT               0xf8200000
-#else
-#define EMAC_RWMR_DEFAULT               0x0f002000
-#define EMAC_TMR0_DEFAULT               0x00000000
-#define EMAC_TMR1_DEFAULT               0x380f0000
-#endif                          /* CONFIG_440GP */
-
-/* Revision specific EMAC register defaults */
-#ifdef CONFIG_IBM_EMAC4
-#define EMAC_M1_DEFAULT                 (EMAC_M1_BASE | \
-                                        EMAC_M1_OPB_CLK_83 | \
-                                        EMAC_M1_TX_MWSW)
-#define EMAC_RMR_DEFAULT                (EMAC_RMR_BASE | \
-                                        EMAC_RMR_RFAF_128_2048)
-#define EMAC_TMR0_XMIT                  (EMAC_TMR0_GNP0 | \
-                                        EMAC_TMR0_DEFAULT)
-#define EMAC_TRTR_DEFAULT               EMAC_TRTR_1024
-#else                           /* !CONFIG_IBM_EMAC4 */
-#define EMAC_M1_DEFAULT                 EMAC_M1_BASE
-#define EMAC_RMR_DEFAULT                EMAC_RMR_BASE
-#define EMAC_TMR0_XMIT                  EMAC_TMR0_GNP0
-#define EMAC_TRTR_DEFAULT               EMAC_TRTR_1600
-#endif                          /* CONFIG_IBM_EMAC4 */
-
-#endif
+#define EMAC_RX_TAH_BAD_CSUM            0x0003
+#define EMAC_BAD_RX_MASK                (EMAC_RX_ST_OE | EMAC_RX_ST_BP | \
+                                         EMAC_RX_ST_RP | EMAC_RX_ST_SE | \
+                                         EMAC_RX_ST_AE | EMAC_RX_ST_BFCS | \
+                                         EMAC_RX_ST_PTL | EMAC_RX_ST_ORE | \
+                                         EMAC_RX_ST_IRE )
+#endif /* __IBM_EMAC_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_core.c b/drivers/net/ibm_emac/ibm_emac_core.c
index 14e9b6315f20..943fbd1546ff 100644
--- a/drivers/net/ibm_emac/ibm_emac_core.c
+++ b/drivers/net/ibm_emac/ibm_emac_core.c
@@ -1,13 +1,14 @@
 /*
- * ibm_emac_core.c
+ * drivers/net/ibm_emac/ibm_emac_core.c
  *
- * Ethernet driver for the built in ethernet on the IBM 4xx PowerPC
- * processors.
- * 
- * (c) 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ * Driver for PowerPC 4xx on-chip ethernet controller.
  *
- * Based on original work by
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
+ * Based on original work by
+ *      Matt Porter <mporter@kernel.crashing.org>
+ *      (c) 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
  *      Armin Kuster <akuster@mvista.com>
  *      Johnnie Peters <jpeters@mvista.com>
  *
@@ -15,29 +16,24 @@
  * 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.
- * TODO
- *       - Check for races in the "remove" code path
- *       - Add some Power Management to the MAC and the PHY
- *       - Audit remaining of non-rewritten code (--BenH)
- *       - Cleanup message display using msglevel mecanism
- *       - Address all errata
- *       - Audit all register update paths to ensure they
- *         are being written post soft reset if required.
+ *
  */
+
+#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/string.h>
-#include <linux/timer.h>
-#include <linux/ptrace.h>
 #include <linux/errno.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/types.h>
-#include <linux/dma-mapping.h>
+#include <linux/pci.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/crc32.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
 #include <linux/bitops.h>
@@ -45,1691 +41,1893 @@
 #include <asm/processor.h>
 #include <asm/io.h>
 #include <asm/dma.h>
-#include <asm/irq.h>
 #include <asm/uaccess.h>
 #include <asm/ocp.h>
 
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/crc32.h>
-
 #include "ibm_emac_core.h"
-
-//#define MDIO_DEBUG(fmt) printk fmt
-#define MDIO_DEBUG(fmt)
-
-//#define LINK_DEBUG(fmt) printk fmt
-#define LINK_DEBUG(fmt)
-
-//#define PKT_DEBUG(fmt) printk fmt
-#define PKT_DEBUG(fmt)
-
-#define DRV_NAME        "emac"
-#define DRV_VERSION     "2.0"
-#define DRV_AUTHOR      "Benjamin Herrenschmidt <benh@kernel.crashing.org>"
-#define DRV_DESC        "IBM EMAC Ethernet driver"
+#include "ibm_emac_debug.h"
 
 /*
- * When mdio_idx >= 0, contains a list of emac ocp_devs
- * that have had their initialization deferred until the
- * common MDIO controller has been initialized.
+ * Lack of dma_unmap_???? calls is intentional.
+ *
+ * API-correct usage requires additional support state information to be 
+ * maintained for every RX and TX buffer descriptor (BD). Unfortunately, due to
+ * EMAC design (e.g. TX buffer passed from network stack can be split into
+ * several BDs, dma_map_single/dma_map_page can be used to map particular BD),
+ * maintaining such information will add additional overhead.
+ * Current DMA API implementation for 4xx processors only ensures cache coherency
+ * and dma_unmap_???? routines are empty and are likely to stay this way.
+ * I decided to omit dma_unmap_??? calls because I don't want to add additional
+ * complexity just for the sake of following some abstract API, when it doesn't
+ * add any real benefit to the driver. I understand that this decision maybe 
+ * controversial, but I really tried to make code API-correct and efficient 
+ * at the same time and didn't come up with code I liked :(.                --ebs
  */
-LIST_HEAD(emac_init_list);
 
-MODULE_AUTHOR(DRV_AUTHOR);
+#define DRV_NAME        "emac"
+#define DRV_VERSION     "3.53"
+#define DRV_DESC        "PPC 4xx OCP EMAC driver"
+
 MODULE_DESCRIPTION(DRV_DESC);
+MODULE_AUTHOR
+    ("Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>");
 MODULE_LICENSE("GPL");
 
-static int skb_res = SKB_RES;
-module_param(skb_res, int, 0444);
-MODULE_PARM_DESC(skb_res, "Amount of data to reserve on skb buffs\n"
-                 "The 405 handles a misaligned IP header fine but\n"
-                 "this can help if you are routing to a tunnel or a\n"
-                 "device that needs aligned data. 0..2");
-
-#define RGMII_PRIV(ocpdev) ((struct ibm_ocp_rgmii*)ocp_get_drvdata(ocpdev))
+/* minimum number of free TX descriptors required to wake up TX process */
+#define EMAC_TX_WAKEUP_THRESH           (NUM_TX_BUFF / 4)
 
-static unsigned int rgmii_enable[] = {
-        RGMII_RTBI,
-        RGMII_RGMII,
-        RGMII_TBI,
-        RGMII_GMII
-};
+/* If packet size is less than this number, we allocate small skb and copy packet 
+ * contents into it instead of just sending original big skb up
+ */
+#define EMAC_RX_COPY_THRESH             CONFIG_IBM_EMAC_RX_COPY_THRESHOLD
 
-static unsigned int rgmii_speed_mask[] = {
-        RGMII_MII2_SPDMASK,
-        RGMII_MII3_SPDMASK
-};
+/* Since multiple EMACs share MDIO lines in various ways, we need
+ * to avoid re-using the same PHY ID in cases where the arch didn't
+ * setup precise phy_map entries
+ */
+static u32 busy_phy_map;
 
-static unsigned int rgmii_speed100[] = {
-        RGMII_MII2_100MB,
-        RGMII_MII3_100MB
-};
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX) && (defined(CONFIG_405EP) || defined(CONFIG_440EP))
+/* 405EP has "EMAC to PHY Control Register" (CPC0_EPCTL) which can help us
+ * with PHY RX clock problem.
+ * 440EP has more sane SDR0_MFR register implementation than 440GX, which
+ * also allows controlling each EMAC clock
+ */
+static inline void EMAC_RX_CLK_TX(int idx)
+{
+        unsigned long flags;
+        local_irq_save(flags);
 
-static unsigned int rgmii_speed1000[] = {
-        RGMII_MII2_1000MB,
-        RGMII_MII3_1000MB
-};
+#if defined(CONFIG_405EP)
+        mtdcr(0xf3, mfdcr(0xf3) | (1 << idx));
+#else /* CONFIG_440EP */
+        SDR_WRITE(DCRN_SDR_MFR, SDR_READ(DCRN_SDR_MFR) | (0x08000000 >> idx));
+#endif
 
-#define ZMII_PRIV(ocpdev) ((struct ibm_ocp_zmii*)ocp_get_drvdata(ocpdev))
+        local_irq_restore(flags);
+}
 
-static unsigned int zmii_enable[][4] = {
-        {ZMII_SMII0, ZMII_RMII0, ZMII_MII0,
-         ~(ZMII_MDI1 | ZMII_MDI2 | ZMII_MDI3)},
-        {ZMII_SMII1, ZMII_RMII1, ZMII_MII1,
-         ~(ZMII_MDI0 | ZMII_MDI2 | ZMII_MDI3)},
-        {ZMII_SMII2, ZMII_RMII2, ZMII_MII2,
-         ~(ZMII_MDI0 | ZMII_MDI1 | ZMII_MDI3)},
-        {ZMII_SMII3, ZMII_RMII3, ZMII_MII3, ~(ZMII_MDI0 | ZMII_MDI1 | ZMII_MDI2)}
-};
+static inline void EMAC_RX_CLK_DEFAULT(int idx)
+{
+        unsigned long flags;
+        local_irq_save(flags);
 
-static unsigned int mdi_enable[] = {
-        ZMII_MDI0,
-        ZMII_MDI1,
-        ZMII_MDI2,
-        ZMII_MDI3
-};
+#if defined(CONFIG_405EP)
+        mtdcr(0xf3, mfdcr(0xf3) & ~(1 << idx));
+#else /* CONFIG_440EP */
+        SDR_WRITE(DCRN_SDR_MFR, SDR_READ(DCRN_SDR_MFR) & ~(0x08000000 >> idx));
+#endif
 
-static unsigned int zmii_speed = 0x0;
-static unsigned int zmii_speed100[] = {
-        ZMII_MII0_100MB,
-        ZMII_MII1_100MB,
-        ZMII_MII2_100MB,
-        ZMII_MII3_100MB
-};
+        local_irq_restore(flags);
+}
+#else
+#define EMAC_RX_CLK_TX(idx)             ((void)0)
+#define EMAC_RX_CLK_DEFAULT(idx)        ((void)0)
+#endif
 
-/* Since multiple EMACs share MDIO lines in various ways, we need
- * to avoid re-using the same PHY ID in cases where the arch didn't
- * setup precise phy_map entries
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX) && defined(CONFIG_440GX)
+/* We can switch Ethernet clock to the internal source through SDR0_MFR[ECS],
+ * unfortunately this is less flexible than 440EP case, because it's a global 
+ * setting for all EMACs, therefore we do this clock trick only during probe.
  */
-static u32 busy_phy_map = 0;
+#define EMAC_CLK_INTERNAL               SDR_WRITE(DCRN_SDR_MFR, \
+                                            SDR_READ(DCRN_SDR_MFR) | 0x08000000)
+#define EMAC_CLK_EXTERNAL               SDR_WRITE(DCRN_SDR_MFR, \
+                                            SDR_READ(DCRN_SDR_MFR) & ~0x08000000)
+#else
+#define EMAC_CLK_INTERNAL               ((void)0)
+#define EMAC_CLK_EXTERNAL               ((void)0)
+#endif
 
-/* If EMACs share a common MDIO device, this points to it */
-static struct net_device *mdio_ndev = NULL;
+/* I don't want to litter system log with timeout errors 
+ * when we have brain-damaged PHY.
+ */
+static inline void emac_report_timeout_error(struct ocp_enet_private *dev,
+                                             const char *error)
+{
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX)
+        DBG("%d: %s" NL, dev->def->index, error);
+#else
+        if (net_ratelimit())
+                printk(KERN_ERR "emac%d: %s\n", dev->def->index, error);
+#endif
+}
 
-struct emac_def_dev {
-        struct list_head link;
-        struct ocp_device *ocpdev;
-        struct ibm_ocp_mal *mal;
+/* PHY polling intervals */
+#define PHY_POLL_LINK_ON        HZ
+#define PHY_POLL_LINK_OFF       (HZ / 5)
+
+/* Please, keep in sync with struct ibm_emac_stats/ibm_emac_error_stats */
+static const char emac_stats_keys[EMAC_ETHTOOL_STATS_COUNT][ETH_GSTRING_LEN] = {
+        "rx_packets", "rx_bytes", "tx_packets", "tx_bytes", "rx_packets_csum",
+        "tx_packets_csum", "tx_undo", "rx_dropped_stack", "rx_dropped_oom",
+        "rx_dropped_error", "rx_dropped_resize", "rx_dropped_mtu",
+        "rx_stopped", "rx_bd_errors", "rx_bd_overrun", "rx_bd_bad_packet",
+        "rx_bd_runt_packet", "rx_bd_short_event", "rx_bd_alignment_error",
+        "rx_bd_bad_fcs", "rx_bd_packet_too_long", "rx_bd_out_of_range",
+        "rx_bd_in_range", "rx_parity", "rx_fifo_overrun", "rx_overrun",
+        "rx_bad_packet", "rx_runt_packet", "rx_short_event",
+        "rx_alignment_error", "rx_bad_fcs", "rx_packet_too_long",
+        "rx_out_of_range", "rx_in_range", "tx_dropped", "tx_bd_errors",
+        "tx_bd_bad_fcs", "tx_bd_carrier_loss", "tx_bd_excessive_deferral",
+        "tx_bd_excessive_collisions", "tx_bd_late_collision",
+        "tx_bd_multple_collisions", "tx_bd_single_collision",
+        "tx_bd_underrun", "tx_bd_sqe", "tx_parity", "tx_underrun", "tx_sqe",
+        "tx_errors"
 };
 
-static struct net_device_stats *emac_stats(struct net_device *dev)
+static irqreturn_t emac_irq(int irq, void *dev_instance, struct pt_regs *regs);
+static void emac_clean_tx_ring(struct ocp_enet_private *dev);
+
+static inline int emac_phy_supports_gige(int phy_mode)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        return &fep->stats;
-};
+        return  phy_mode == PHY_MODE_GMII ||
+                phy_mode == PHY_MODE_RGMII ||
+                phy_mode == PHY_MODE_TBI ||
+                phy_mode == PHY_MODE_RTBI;
+}
 
-static int
-emac_init_rgmii(struct ocp_device *rgmii_dev, int input, int phy_mode)
+static inline int emac_phy_gpcs(int phy_mode)
 {
-        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(rgmii_dev);
-        const char *mode_name[] = { "RTBI", "RGMII", "TBI", "GMII" };
-        int mode = -1;
+        return  phy_mode == PHY_MODE_TBI ||
+                phy_mode == PHY_MODE_RTBI;
+}
 
-        if (!rgmii) {
-                rgmii = kmalloc(sizeof(struct ibm_ocp_rgmii), GFP_KERNEL);
+static inline void emac_tx_enable(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-                if (rgmii == NULL) {
-                        printk(KERN_ERR
-                               "rgmii%d: Out of memory allocating RGMII structure!\n",
-                               rgmii_dev->def->index);
-                        return -ENOMEM;
-                }
+        local_irq_save(flags);
 
-                memset(rgmii, 0, sizeof(*rgmii));
+        DBG("%d: tx_enable" NL, dev->def->index);
 
-                rgmii->base =
-                    (struct rgmii_regs *)ioremap(rgmii_dev->def->paddr,
-                                                 sizeof(*rgmii->base));
-                if (rgmii->base == NULL) {
-                        printk(KERN_ERR
-                               "rgmii%d: Cannot ioremap bridge registers!\n",
-                               rgmii_dev->def->index);
+        r = in_be32(&p->mr0);
+        if (!(r & EMAC_MR0_TXE))
+                out_be32(&p->mr0, r | EMAC_MR0_TXE);
+        local_irq_restore(flags);
+}
 
-                        kfree(rgmii);
-                        return -ENOMEM;
-                }
-                ocp_set_drvdata(rgmii_dev, rgmii);
-        }
+static void emac_tx_disable(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        if (phy_mode) {
-                switch (phy_mode) {
-                case PHY_MODE_GMII:
-                        mode = GMII;
-                        break;
-                case PHY_MODE_TBI:
-                        mode = TBI;
-                        break;
-                case PHY_MODE_RTBI:
-                        mode = RTBI;
-                        break;
-                case PHY_MODE_RGMII:
-                default:
-                        mode = RGMII;
-                }
-                rgmii->base->fer &= ~RGMII_FER_MASK(input);
-                rgmii->base->fer |= rgmii_enable[mode] << (4 * input);
-        } else {
-                switch ((rgmii->base->fer & RGMII_FER_MASK(input)) >> (4 *
-                                                                       input)) {
-                case RGMII_RTBI:
-                        mode = RTBI;
-                        break;
-                case RGMII_RGMII:
-                        mode = RGMII;
-                        break;
-                case RGMII_TBI:
-                        mode = TBI;
-                        break;
-                case RGMII_GMII:
-                        mode = GMII;
-                }
-        }
+        local_irq_save(flags);
+
+        DBG("%d: tx_disable" NL, dev->def->index);
 
-        /* Set mode to RGMII if nothing valid is detected */
-        if (mode < 0)
-                mode = RGMII;
+        r = in_be32(&p->mr0);
+        if (r & EMAC_MR0_TXE) {
+                int n = 300;
+                out_be32(&p->mr0, r & ~EMAC_MR0_TXE);
+                while (!(in_be32(&p->mr0) & EMAC_MR0_TXI) && n)
+                        --n;
+                if (unlikely(!n))
+                        emac_report_timeout_error(dev, "TX disable timeout");
+        }
+        local_irq_restore(flags);
+}
 
-        printk(KERN_NOTICE "rgmii%d: input %d in %s mode\n",
-               rgmii_dev->def->index, input, mode_name[mode]);
+static void emac_rx_enable(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        rgmii->mode[input] = mode;
-        rgmii->users++;
+        local_irq_save(flags);
+        if (unlikely(dev->commac.rx_stopped))
+                goto out;
 
-        return 0;
+        DBG("%d: rx_enable" NL, dev->def->index);
+
+        r = in_be32(&p->mr0);
+        if (!(r & EMAC_MR0_RXE)) {
+                if (unlikely(!(r & EMAC_MR0_RXI))) {
+                        /* Wait if previous async disable is still in progress */
+                        int n = 100;
+                        while (!(r = in_be32(&p->mr0) & EMAC_MR0_RXI) && n)
+                                --n;
+                        if (unlikely(!n))
+                                emac_report_timeout_error(dev,
+                                                          "RX disable timeout");
+                }
+                out_be32(&p->mr0, r | EMAC_MR0_RXE);
+        }
+      out:
+        local_irq_restore(flags);
 }
 
-static void
-emac_rgmii_port_speed(struct ocp_device *ocpdev, int input, int speed)
+static void emac_rx_disable(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(ocpdev);
-        unsigned int rgmii_speed;
-
-        rgmii_speed = in_be32(&rgmii->base->ssr);
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        rgmii_speed &= ~rgmii_speed_mask[input];
+        local_irq_save(flags);
 
-        if (speed == 1000)
-                rgmii_speed |= rgmii_speed1000[input];
-        else if (speed == 100)
-                rgmii_speed |= rgmii_speed100[input];
+        DBG("%d: rx_disable" NL, dev->def->index);
 
-        out_be32(&rgmii->base->ssr, rgmii_speed);
+        r = in_be32(&p->mr0);
+        if (r & EMAC_MR0_RXE) {
+                int n = 300;
+                out_be32(&p->mr0, r & ~EMAC_MR0_RXE);
+                while (!(in_be32(&p->mr0) & EMAC_MR0_RXI) && n)
+                        --n;
+                if (unlikely(!n))
+                        emac_report_timeout_error(dev, "RX disable timeout");
+        }
+        local_irq_restore(flags);
 }
 
-static void emac_close_rgmii(struct ocp_device *ocpdev)
+static inline void emac_rx_disable_async(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(ocpdev);
-        BUG_ON(!rgmii || rgmii->users == 0);
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        u32 r;
 
-        if (!--rgmii->users) {
-                ocp_set_drvdata(ocpdev, NULL);
-                iounmap((void *)rgmii->base);
-                kfree(rgmii);
-        }
+        local_irq_save(flags);
+
+        DBG("%d: rx_disable_async" NL, dev->def->index);
+
+        r = in_be32(&p->mr0);
+        if (r & EMAC_MR0_RXE)
+                out_be32(&p->mr0, r & ~EMAC_MR0_RXE);
+        local_irq_restore(flags);
 }
 
-static int emac_init_zmii(struct ocp_device *zmii_dev, int input, int phy_mode)
+static int emac_reset(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(zmii_dev);
-        const char *mode_name[] = { "SMII", "RMII", "MII" };
-        int mode = -1;
+        struct emac_regs *p = dev->emacp;
+        unsigned long flags;
+        int n = 20;
 
-        if (!zmii) {
-                zmii = kmalloc(sizeof(struct ibm_ocp_zmii), GFP_KERNEL);
-                if (zmii == NULL) {
-                        printk(KERN_ERR
-                               "zmii%d: Out of memory allocating ZMII structure!\n",
-                               zmii_dev->def->index);
-                        return -ENOMEM;
-                }
-                memset(zmii, 0, sizeof(*zmii));
+        DBG("%d: reset" NL, dev->def->index);
 
-                zmii->base =
-                    (struct zmii_regs *)ioremap(zmii_dev->def->paddr,
-                                                sizeof(*zmii->base));
-                if (zmii->base == NULL) {
-                        printk(KERN_ERR
-                               "zmii%d: Cannot ioremap bridge registers!\n",
-                               zmii_dev->def->index);
+        local_irq_save(flags);
 
-                        kfree(zmii);
-                        return -ENOMEM;
-                }
-                ocp_set_drvdata(zmii_dev, zmii);
+        if (!dev->reset_failed) {
+                /* 40x erratum suggests stopping RX channel before reset,
+                 * we stop TX as well
+                 */
+                emac_rx_disable(dev);
+                emac_tx_disable(dev);
         }
 
-        if (phy_mode) {
-                switch (phy_mode) {
-                case PHY_MODE_MII:
-                        mode = MII;
-                        break;
-                case PHY_MODE_RMII:
-                        mode = RMII;
-                        break;
-                case PHY_MODE_SMII:
-                default:
-                        mode = SMII;
-                }
-                zmii->base->fer &= ~ZMII_FER_MASK(input);
-                zmii->base->fer |= zmii_enable[input][mode];
+        out_be32(&p->mr0, EMAC_MR0_SRST);
+        while ((in_be32(&p->mr0) & EMAC_MR0_SRST) && n)
+                --n;
+        local_irq_restore(flags);
+
+        if (n) {
+                dev->reset_failed = 0;
+                return 0;
         } else {
-                switch ((zmii->base->fer & ZMII_FER_MASK(input)) << (4 * input)) {
-                case ZMII_MII0:
-                        mode = MII;
-                        break;
-                case ZMII_RMII0:
-                        mode = RMII;
-                        break;
-                case ZMII_SMII0:
-                        mode = SMII;
-                }
+                emac_report_timeout_error(dev, "reset timeout");
+                dev->reset_failed = 1;
+                return -ETIMEDOUT;
         }
+}
 
-        /* Set mode to SMII if nothing valid is detected */
-        if (mode < 0)
-                mode = SMII;
+static void emac_hash_mc(struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+        u16 gaht[4] = { 0 };
+        struct dev_mc_list *dmi;
 
-        printk(KERN_NOTICE "zmii%d: input %d in %s mode\n",
-               zmii_dev->def->index, input, mode_name[mode]);
+        DBG("%d: hash_mc %d" NL, dev->def->index, dev->ndev->mc_count);
 
-        zmii->mode[input] = mode;
-        zmii->users++;
+        for (dmi = dev->ndev->mc_list; dmi; dmi = dmi->next) {
+                int bit;
+                DBG2("%d: mc %02x:%02x:%02x:%02x:%02x:%02x" NL,
+                     dev->def->index,
+                     dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2],
+                     dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5]);
 
-        return 0;
+                bit = 63 - (ether_crc(ETH_ALEN, dmi->dmi_addr) >> 26);
+                gaht[bit >> 4] |= 0x8000 >> (bit & 0x0f);
+        }
+        out_be32(&p->gaht1, gaht[0]);
+        out_be32(&p->gaht2, gaht[1]);
+        out_be32(&p->gaht3, gaht[2]);
+        out_be32(&p->gaht4, gaht[3]);
 }
 
-static void emac_enable_zmii_port(struct ocp_device *ocpdev, int input)
+static inline u32 emac_iff2rmr(struct net_device *ndev)
 {
-        u32 mask;
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(ocpdev);
+        u32 r = EMAC_RMR_SP | EMAC_RMR_SFCS | EMAC_RMR_IAE | EMAC_RMR_BAE |
+            EMAC_RMR_BASE;
 
-        mask = in_be32(&zmii->base->fer);
-        mask &= zmii_enable[input][MDI];        /* turn all non enabled MDI's off */
-        mask |= zmii_enable[input][zmii->mode[input]] | mdi_enable[input];
-        out_be32(&zmii->base->fer, mask);
+        if (ndev->flags & IFF_PROMISC)
+                r |= EMAC_RMR_PME;
+        else if (ndev->flags & IFF_ALLMULTI || ndev->mc_count > 32)
+                r |= EMAC_RMR_PMME;
+        else if (ndev->mc_count > 0)
+                r |= EMAC_RMR_MAE;
+
+        return r;
 }
 
-static void
-emac_zmii_port_speed(struct ocp_device *ocpdev, int input, int speed)
+static inline int emac_opb_mhz(void)
 {
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(ocpdev);
-
-        if (speed == 100)
-                zmii_speed |= zmii_speed100[input];
-        else
-                zmii_speed &= ~zmii_speed100[input];
-
-        out_be32(&zmii->base->ssr, zmii_speed);
+        return (ocp_sys_info.opb_bus_freq + 500000) / 1000000;
 }
 
-static void emac_close_zmii(struct ocp_device *ocpdev)
+/* BHs disabled */
+static int emac_configure(struct ocp_enet_private *dev)
 {
-        struct ibm_ocp_zmii *zmii = ZMII_PRIV(ocpdev);
-        BUG_ON(!zmii || zmii->users == 0);
+        struct emac_regs *p = dev->emacp;
+        struct net_device *ndev = dev->ndev;
+        int gige;
+        u32 r;
 
-        if (!--zmii->users) {
-                ocp_set_drvdata(ocpdev, NULL);
-                iounmap((void *)zmii->base);
-                kfree(zmii);
-        }
-}
+        DBG("%d: configure" NL, dev->def->index);
 
-int emac_phy_read(struct net_device *dev, int mii_id, int reg)
-{
-        int count;
-        uint32_t stacr;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
+        if (emac_reset(dev) < 0)
+                return -ETIMEDOUT;
 
-        MDIO_DEBUG(("%s: phy_read, id: 0x%x, reg: 0x%x\n", dev->name, mii_id,
-                    reg));
+        tah_reset(dev->tah_dev);
 
-        /* Enable proper ZMII port */
-        if (fep->zmii_dev)
-                emac_enable_zmii_port(fep->zmii_dev, fep->zmii_input);
+        /* Mode register */
+        r = EMAC_MR1_BASE(emac_opb_mhz()) | EMAC_MR1_VLE | EMAC_MR1_IST;
+        if (dev->phy.duplex == DUPLEX_FULL)
+                r |= EMAC_MR1_FDE;
+        switch (dev->phy.speed) {
+        case SPEED_1000:
+                if (emac_phy_gpcs(dev->phy.mode)) {
+                        r |= EMAC_MR1_MF_1000GPCS |
+                            EMAC_MR1_MF_IPPA(dev->phy.address);
 
-        /* Use the EMAC that has the MDIO port */
-        if (fep->mdio_dev) {
-                dev = fep->mdio_dev;
-                fep = dev->priv;
-                emacp = fep->emacp;
+                        /* Put some arbitrary OUI, Manuf & Rev IDs so we can
+                         * identify this GPCS PHY later.
+                         */
+                        out_be32(&p->ipcr, 0xdeadbeef);
+                } else
+                        r |= EMAC_MR1_MF_1000;
+                r |= EMAC_MR1_RFS_16K;
+                gige = 1;
+                
+                if (dev->ndev->mtu > ETH_DATA_LEN)
+                        r |= EMAC_MR1_JPSM;
+                break;
+        case SPEED_100:
+                r |= EMAC_MR1_MF_100;
+                /* Fall through */
+        default:
+                r |= EMAC_MR1_RFS_4K;
+                gige = 0;
+                break;
         }
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
-                udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+        if (dev->rgmii_dev)
+                rgmii_set_speed(dev->rgmii_dev, dev->rgmii_input,
+                                dev->phy.speed);
+        else
+                zmii_set_speed(dev->zmii_dev, dev->zmii_input, dev->phy.speed);
 
-        if ((stacr & EMAC_STACR_OC) == 0) {
-                printk(KERN_WARNING "%s: PHY read timeout #1!\n", dev->name);
-                return -1;
+#if !defined(CONFIG_40x)
+        /* on 40x erratum forces us to NOT use integrated flow control, 
+         * let's hope it works on 44x ;)
+         */
+        if (dev->phy.duplex == DUPLEX_FULL) {
+                if (dev->phy.pause)
+                        r |= EMAC_MR1_EIFC | EMAC_MR1_APP;
+                else if (dev->phy.asym_pause)
+                        r |= EMAC_MR1_APP;
         }
+#endif
+        out_be32(&p->mr1, r);
+
+        /* Set individual MAC address */
+        out_be32(&p->iahr, (ndev->dev_addr[0] << 8) | ndev->dev_addr[1]);
+        out_be32(&p->ialr, (ndev->dev_addr[2] << 24) |
+                 (ndev->dev_addr[3] << 16) | (ndev->dev_addr[4] << 8) |
+                 ndev->dev_addr[5]);
+
+        /* VLAN Tag Protocol ID */
+        out_be32(&p->vtpid, 0x8100);
+
+        /* Receive mode register */
+        r = emac_iff2rmr(ndev);
+        if (r & EMAC_RMR_MAE)
+                emac_hash_mc(dev);
+        out_be32(&p->rmr, r);
+
+        /* FIFOs thresholds */
+        r = EMAC_TMR1((EMAC_MAL_BURST_SIZE / EMAC_FIFO_ENTRY_SIZE) + 1,
+                      EMAC_TX_FIFO_SIZE / 2 / EMAC_FIFO_ENTRY_SIZE);
+        out_be32(&p->tmr1, r);
+        out_be32(&p->trtr, EMAC_TRTR(EMAC_TX_FIFO_SIZE / 2));
+
+        /* PAUSE frame is sent when RX FIFO reaches its high-water mark,
+           there should be still enough space in FIFO to allow the our link
+           partner time to process this frame and also time to send PAUSE 
+           frame itself.
+
+           Here is the worst case scenario for the RX FIFO "headroom"
+           (from "The Switch Book") (100Mbps, without preamble, inter-frame gap):
+
+           1) One maximum-length frame on TX                    1522 bytes
+           2) One PAUSE frame time                                64 bytes
+           3) PAUSE frame decode time allowance                   64 bytes
+           4) One maximum-length frame on RX                    1522 bytes
+           5) Round-trip propagation delay of the link (100Mb)    15 bytes
+           ----------       
+           3187 bytes
+
+           I chose to set high-water mark to RX_FIFO_SIZE / 4 (1024 bytes)
+           low-water mark  to RX_FIFO_SIZE / 8 (512 bytes)
+         */
+        r = EMAC_RWMR(EMAC_RX_FIFO_SIZE(gige) / 8 / EMAC_FIFO_ENTRY_SIZE,
+                      EMAC_RX_FIFO_SIZE(gige) / 4 / EMAC_FIFO_ENTRY_SIZE);
+        out_be32(&p->rwmr, r);
+
+        /* Set PAUSE timer to the maximum */
+        out_be32(&p->ptr, 0xffff);
+
+        /* IRQ sources */
+        out_be32(&p->iser, EMAC_ISR_TXPE | EMAC_ISR_RXPE | /* EMAC_ISR_TXUE |
+                 EMAC_ISR_RXOE | */ EMAC_ISR_OVR | EMAC_ISR_BP | EMAC_ISR_SE |
+                 EMAC_ISR_ALE | EMAC_ISR_BFCS | EMAC_ISR_PTLE | EMAC_ISR_ORE |
+                 EMAC_ISR_IRE | EMAC_ISR_TE);
+                 
+        /* We need to take GPCS PHY out of isolate mode after EMAC reset */
+        if (emac_phy_gpcs(dev->phy.mode)) 
+                mii_reset_phy(&dev->phy);
+                 
+        return 0;
+}
 
-        /* Clear the speed bits and make a read request to the PHY */
-        stacr = ((EMAC_STACR_READ | (reg & 0x1f)) & ~EMAC_STACR_CLK_100MHZ);
-        stacr |= ((mii_id & 0x1F) << 5);
+/* BHs disabled */
+static void emac_reinitialize(struct ocp_enet_private *dev)
+{
+        DBG("%d: reinitialize" NL, dev->def->index);
 
-        out_be32(&emacp->em0stacr, stacr);
+        if (!emac_configure(dev)) {
+                emac_tx_enable(dev);
+                emac_rx_enable(dev);
+        }
+}
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
-                udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+/* BHs disabled */
+static void emac_full_tx_reset(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
 
-        if ((stacr & EMAC_STACR_OC) == 0) {
-                printk(KERN_WARNING "%s: PHY read timeout #2!\n", dev->name);
-                return -1;
-        }
+        DBG("%d: full_tx_reset" NL, dev->def->index);
 
-        /* Check for a read error */
-        if (stacr & EMAC_STACR_PHYE) {
-                MDIO_DEBUG(("EMAC MDIO PHY error !\n"));
-                return -1;
-        }
+        emac_tx_disable(dev);
+        mal_disable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        emac_clean_tx_ring(dev);
+        dev->tx_cnt = dev->tx_slot = dev->ack_slot = 0;
 
-        MDIO_DEBUG((" -> 0x%x\n", stacr >> 16));
+        emac_configure(dev);
 
-        return (stacr >> 16);
+        mal_enable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        emac_tx_enable(dev);
+        emac_rx_enable(dev);
+
+        netif_wake_queue(ndev);
 }
 
-void emac_phy_write(struct net_device *dev, int mii_id, int reg, int data)
+static int __emac_mdio_read(struct ocp_enet_private *dev, u8 id, u8 reg)
 {
-        int count;
-        uint32_t stacr;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
+        struct emac_regs *p = dev->emacp;
+        u32 r;
+        int n;
 
-        MDIO_DEBUG(("%s phy_write, id: 0x%x, reg: 0x%x, data: 0x%x\n",
-                    dev->name, mii_id, reg, data));
+        DBG2("%d: mdio_read(%02x,%02x)" NL, dev->def->index, id, reg);
 
-        /* Enable proper ZMII port */
-        if (fep->zmii_dev)
-                emac_enable_zmii_port(fep->zmii_dev, fep->zmii_input);
+        /* Enable proper MDIO port */
+        zmii_enable_mdio(dev->zmii_dev, dev->zmii_input);
 
-        /* Use the EMAC that has the MDIO port */
-        if (fep->mdio_dev) {
-                dev = fep->mdio_dev;
-                fep = dev->priv;
-                emacp = fep->emacp;
+        /* Wait for management interface to become idle */
+        n = 10;
+        while (!(in_be32(&p->stacr) & EMAC_STACR_OC)) {
+                udelay(1);
+                if (!--n)
+                        goto to;
         }
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
+        /* Issue read command */
+        out_be32(&p->stacr,
+                 EMAC_STACR_BASE(emac_opb_mhz()) | EMAC_STACR_STAC_READ |
+                 (reg & EMAC_STACR_PRA_MASK)
+                 | ((id & EMAC_STACR_PCDA_MASK) << EMAC_STACR_PCDA_SHIFT));
+
+        /* Wait for read to complete */
+        n = 100;
+        while (!((r = in_be32(&p->stacr)) & EMAC_STACR_OC)) {
                 udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+                if (!--n)
+                        goto to;
+        }
 
-        if ((stacr & EMAC_STACR_OC) == 0) {
-                printk(KERN_WARNING "%s: PHY write timeout #2!\n", dev->name);
-                return;
+        if (unlikely(r & EMAC_STACR_PHYE)) {
+                DBG("%d: mdio_read(%02x, %02x) failed" NL, dev->def->index,
+                    id, reg);
+                return -EREMOTEIO;
         }
 
-        /* Clear the speed bits and make a read request to the PHY */
+        r = ((r >> EMAC_STACR_PHYD_SHIFT) & EMAC_STACR_PHYD_MASK);
+        DBG2("%d: mdio_read -> %04x" NL, dev->def->index, r);
+        return r;
+      to:
+        DBG("%d: MII management interface timeout (read)" NL, dev->def->index);
+        return -ETIMEDOUT;
+}
 
-        stacr = ((EMAC_STACR_WRITE | (reg & 0x1f)) & ~EMAC_STACR_CLK_100MHZ);
-        stacr |= ((mii_id & 0x1f) << 5) | ((data & 0xffff) << 16);
+static void __emac_mdio_write(struct ocp_enet_private *dev, u8 id, u8 reg,
+                              u16 val)
+{
+        struct emac_regs *p = dev->emacp;
+        int n;
 
-        out_be32(&emacp->em0stacr, stacr);
+        DBG2("%d: mdio_write(%02x,%02x,%04x)" NL, dev->def->index, id, reg,
+             val);
 
-        count = 0;
-        while ((((stacr = in_be32(&emacp->em0stacr)) & EMAC_STACR_OC) == 0)
-                                        && (count++ < MDIO_DELAY))
+        /* Enable proper MDIO port */
+        zmii_enable_mdio(dev->zmii_dev, dev->zmii_input);
+
+        /* Wait for management interface to be idle */
+        n = 10;
+        while (!(in_be32(&p->stacr) & EMAC_STACR_OC)) {
                 udelay(1);
-        MDIO_DEBUG((" (count was %d)\n", count));
+                if (!--n)
+                        goto to;
+        }
 
-        if ((stacr & EMAC_STACR_OC) == 0)
-                printk(KERN_WARNING "%s: PHY write timeout #2!\n", dev->name);
+        /* Issue write command */
+        out_be32(&p->stacr,
+                 EMAC_STACR_BASE(emac_opb_mhz()) | EMAC_STACR_STAC_WRITE |
+                 (reg & EMAC_STACR_PRA_MASK) |
+                 ((id & EMAC_STACR_PCDA_MASK) << EMAC_STACR_PCDA_SHIFT) |
+                 (val << EMAC_STACR_PHYD_SHIFT));
 
-        /* Check for a write error */
-        if ((stacr & EMAC_STACR_PHYE) != 0) {
-                MDIO_DEBUG(("EMAC MDIO PHY error !\n"));
+        /* Wait for write to complete */
+        n = 100;
+        while (!(in_be32(&p->stacr) & EMAC_STACR_OC)) {
+                udelay(1);
+                if (!--n)
+                        goto to;
         }
+        return;
+      to:
+        DBG("%d: MII management interface timeout (write)" NL, dev->def->index);
 }
 
-static void emac_txeob_dev(void *param, u32 chanmask)
+static int emac_mdio_read(struct net_device *ndev, int id, int reg)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long flags;
-
-        spin_lock_irqsave(&fep->lock, flags);
-
-        PKT_DEBUG(("emac_txeob_dev() entry, tx_cnt: %d\n", fep->tx_cnt));
-
-        while (fep->tx_cnt &&
-               !(fep->tx_desc[fep->ack_slot].ctrl & MAL_TX_CTRL_READY)) {
+        struct ocp_enet_private *dev = ndev->priv;
+        int res;
+
+        local_bh_disable();
+        res = __emac_mdio_read(dev->mdio_dev ? dev->mdio_dev : dev, (u8) id,
+                               (u8) reg);
+        local_bh_enable();
+        return res;
+}
 
-                if (fep->tx_desc[fep->ack_slot].ctrl & MAL_TX_CTRL_LAST) {
-                        /* Tell the system the transmit completed. */
-                        dma_unmap_single(&fep->ocpdev->dev,
-                                         fep->tx_desc[fep->ack_slot].data_ptr,
-                                         fep->tx_desc[fep->ack_slot].data_len,
-                                         DMA_TO_DEVICE);
-                        dev_kfree_skb_irq(fep->tx_skb[fep->ack_slot]);
+static void emac_mdio_write(struct net_device *ndev, int id, int reg, int val)
+{
+        struct ocp_enet_private *dev = ndev->priv;
 
-                        if (fep->tx_desc[fep->ack_slot].ctrl &
-                            (EMAC_TX_ST_EC | EMAC_TX_ST_MC | EMAC_TX_ST_SC))
-                                fep->stats.collisions++;
-                }
+        local_bh_disable();
+        __emac_mdio_write(dev->mdio_dev ? dev->mdio_dev : dev, (u8) id,
+                          (u8) reg, (u16) val);
+        local_bh_enable();
+}
 
-                fep->tx_skb[fep->ack_slot] = (struct sk_buff *)NULL;
-                if (++fep->ack_slot == NUM_TX_BUFF)
-                        fep->ack_slot = 0;
+/* BHs disabled */
+static void emac_set_multicast_list(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct emac_regs *p = dev->emacp;
+        u32 rmr = emac_iff2rmr(ndev);
+
+        DBG("%d: multicast %08x" NL, dev->def->index, rmr);
+        BUG_ON(!netif_running(dev->ndev));
+
+        /* I decided to relax register access rules here to avoid
+         * full EMAC reset.
+         *
+         * There is a real problem with EMAC4 core if we use MWSW_001 bit 
+         * in MR1 register and do a full EMAC reset.
+         * One TX BD status update is delayed and, after EMAC reset, it 
+         * never happens, resulting in TX hung (it'll be recovered by TX 
+         * timeout handler eventually, but this is just gross).
+         * So we either have to do full TX reset or try to cheat here :)
+         *
+         * The only required change is to RX mode register, so I *think* all
+         * we need is just to stop RX channel. This seems to work on all
+         * tested SoCs.                                                --ebs
+         */
+        emac_rx_disable(dev);
+        if (rmr & EMAC_RMR_MAE)
+                emac_hash_mc(dev);
+        out_be32(&p->rmr, rmr);
+        emac_rx_enable(dev);
+}
 
-                fep->tx_cnt--;
+/* BHs disabled */
+static int emac_resize_rx_ring(struct ocp_enet_private *dev, int new_mtu)
+{
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+        int rx_sync_size = emac_rx_sync_size(new_mtu);
+        int rx_skb_size = emac_rx_skb_size(new_mtu);
+        int i, ret = 0;
+
+        emac_rx_disable(dev);
+        mal_disable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+
+        if (dev->rx_sg_skb) {
+                ++dev->estats.rx_dropped_resize;
+                dev_kfree_skb(dev->rx_sg_skb);
+                dev->rx_sg_skb = NULL;
         }
-        if (fep->tx_cnt < NUM_TX_BUFF)
-                netif_wake_queue(dev);
 
-        PKT_DEBUG(("emac_txeob_dev() exit, tx_cnt: %d\n", fep->tx_cnt));
+        /* Make a first pass over RX ring and mark BDs ready, dropping 
+         * non-processed packets on the way. We need this as a separate pass
+         * to simplify error recovery in the case of allocation failure later.
+         */
+        for (i = 0; i < NUM_RX_BUFF; ++i) {
+                if (dev->rx_desc[i].ctrl & MAL_RX_CTRL_FIRST)
+                        ++dev->estats.rx_dropped_resize;
 
-        spin_unlock_irqrestore(&fep->lock, flags);
-}
+                dev->rx_desc[i].data_len = 0;
+                dev->rx_desc[i].ctrl = MAL_RX_CTRL_EMPTY |
+                    (i == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
+        }
 
-/*
-  Fill/Re-fill the rx chain with valid ctrl/ptrs.
-  This function will fill from rx_slot up to the parm end.
-  So to completely fill the chain pre-set rx_slot to 0 and
-  pass in an end of 0.
- */
-static void emac_rx_fill(struct net_device *dev, int end)
-{
-        int i;
-        struct ocp_enet_private *fep = dev->priv;
-
-        i = fep->rx_slot;
-        do {
-                /* We don't want the 16 bytes skb_reserve done by dev_alloc_skb,
-                 * it breaks our cache line alignement. However, we still allocate
-                 * +16 so that we end up allocating the exact same size as
-                 * dev_alloc_skb() would do.
-                 * Also, because of the skb_res, the max DMA size we give to EMAC
-                 * is slighly wrong, causing it to potentially DMA 2 more bytes
-                 * from a broken/oversized packet. These 16 bytes will take care
-                 * that we don't walk on somebody else toes with that.
-                 */
-                fep->rx_skb[i] =
-                    alloc_skb(fep->rx_buffer_size + 16, GFP_ATOMIC);
-
-                if (fep->rx_skb[i] == NULL) {
-                        /* Keep rx_slot here, the next time clean/fill is called
-                         * we will try again before the MAL wraps back here
-                         * If the MAL tries to use this descriptor with
-                         * the EMPTY bit off it will cause the
-                         * rxde interrupt.  That is where we will
-                         * try again to allocate an sk_buff.
-                         */
-                        break;
+        /* Reallocate RX ring only if bigger skb buffers are required */
+        if (rx_skb_size <= dev->rx_skb_size)
+                goto skip;
 
+        /* Second pass, allocate new skbs */
+        for (i = 0; i < NUM_RX_BUFF; ++i) {
+                struct sk_buff *skb = alloc_skb(rx_skb_size, GFP_ATOMIC);
+                if (!skb) {
+                        ret = -ENOMEM;
+                        goto oom;
                 }
 
-                if (skb_res)
-                        skb_reserve(fep->rx_skb[i], skb_res);
+                BUG_ON(!dev->rx_skb[i]);
+                dev_kfree_skb(dev->rx_skb[i]);
 
-                /* We must NOT dma_map_single the cache line right after the
-                 * buffer, so we must crop our sync size to account for the
-                 * reserved space
-                 */
-                fep->rx_desc[i].data_ptr =
-                    (unsigned char *)dma_map_single(&fep->ocpdev->dev,
-                                                    (void *)fep->rx_skb[i]->
-                                                    data,
-                                                    fep->rx_buffer_size -
-                                                    skb_res, DMA_FROM_DEVICE);
-
-                /*
-                 * Some 4xx implementations use the previously
-                 * reserved bits in data_len to encode the MS
-                 * 4-bits of a 36-bit physical address (ERPN)
-                 * This must be initialized.
-                 */
-                fep->rx_desc[i].data_len = 0;
-                fep->rx_desc[i].ctrl = MAL_RX_CTRL_EMPTY | MAL_RX_CTRL_INTR |
-                    (i == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
+                skb_reserve(skb, EMAC_RX_SKB_HEADROOM + 2);
+                dev->rx_desc[i].data_ptr =
+                    dma_map_single(dev->ldev, skb->data - 2, rx_sync_size,
+                                   DMA_FROM_DEVICE) + 2;
+                dev->rx_skb[i] = skb;
+        }
+      skip:
+        /* Check if we need to change "Jumbo" bit in MR1 */
+        if ((new_mtu > ETH_DATA_LEN) ^ (dev->ndev->mtu > ETH_DATA_LEN)) {
+                /* This is to prevent starting RX channel in emac_rx_enable() */
+                dev->commac.rx_stopped = 1;
+
+                dev->ndev->mtu = new_mtu;
+                emac_full_tx_reset(dev->ndev);
+        }
 
-        } while ((i = (i + 1) % NUM_RX_BUFF) != end);
+        mal_set_rcbs(dev->mal, emacdata->mal_rx_chan, emac_rx_size(new_mtu));
+      oom:
+        /* Restart RX */
+        dev->commac.rx_stopped = dev->rx_slot = 0;
+        mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+        emac_rx_enable(dev);
 
-        fep->rx_slot = i;
+        return ret;
 }
 
-static void
-emac_rx_csum(struct net_device *dev, unsigned short ctrl, struct sk_buff *skb)
+/* Process ctx, rtnl_lock semaphore */
+static int emac_change_mtu(struct net_device *ndev, int new_mtu)
 {
-        struct ocp_enet_private *fep = dev->priv;
+        struct ocp_enet_private *dev = ndev->priv;
+        int ret = 0;
 
-        /* Exit if interface has no TAH engine */
-        if (!fep->tah_dev) {
-                skb->ip_summed = CHECKSUM_NONE;
-                return;
-        }
+        if (new_mtu < EMAC_MIN_MTU || new_mtu > EMAC_MAX_MTU)
+                return -EINVAL;
 
-        /* Check for TCP/UDP/IP csum error */
-        if (ctrl & EMAC_CSUM_VER_ERROR) {
-                /* Let the stack verify checksum errors */
-                skb->ip_summed = CHECKSUM_NONE;
-/*              adapter->hw_csum_err++; */
-        } else {
-                /* Csum is good */
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-/*              adapter->hw_csum_good++; */
-        }
-}
+        DBG("%d: change_mtu(%d)" NL, dev->def->index, new_mtu);
 
-static int emac_rx_clean(struct net_device *dev)
-{
-        int i, b, bnum = 0, buf[6];
-        int error, frame_length;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned short ctrl;
+        local_bh_disable();
+        if (netif_running(ndev)) {
+                /* Check if we really need to reinitalize RX ring */
+                if (emac_rx_skb_size(ndev->mtu) != emac_rx_skb_size(new_mtu))
+                        ret = emac_resize_rx_ring(dev, new_mtu);
+        }
 
-        i = fep->rx_slot;
+        if (!ret) {
+                ndev->mtu = new_mtu;
+                dev->rx_skb_size = emac_rx_skb_size(new_mtu);
+                dev->rx_sync_size = emac_rx_sync_size(new_mtu);
+        }       
+        local_bh_enable();
 
-        PKT_DEBUG(("emac_rx_clean() entry, rx_slot: %d\n", fep->rx_slot));
+        return ret;
+}
 
-        do {
-                if (fep->rx_skb[i] == NULL)
-                        continue;       /*we have already handled the packet but haved failed to alloc */
-                /* 
-                   since rx_desc is in uncached mem we don't keep reading it directly 
-                   we pull out a local copy of ctrl and do the checks on the copy.
-                 */
-                ctrl = fep->rx_desc[i].ctrl;
-                if (ctrl & MAL_RX_CTRL_EMPTY)
-                        break;  /*we don't have any more ready packets */
-
-                if (EMAC_IS_BAD_RX_PACKET(ctrl)) {
-                        fep->stats.rx_errors++;
-                        fep->stats.rx_dropped++;
-
-                        if (ctrl & EMAC_RX_ST_OE)
-                                fep->stats.rx_fifo_errors++;
-                        if (ctrl & EMAC_RX_ST_AE)
-                                fep->stats.rx_frame_errors++;
-                        if (ctrl & EMAC_RX_ST_BFCS)
-                                fep->stats.rx_crc_errors++;
-                        if (ctrl & (EMAC_RX_ST_RP | EMAC_RX_ST_PTL |
-                                    EMAC_RX_ST_ORE | EMAC_RX_ST_IRE))
-                                fep->stats.rx_length_errors++;
-                } else {
-                        if ((ctrl & (MAL_RX_CTRL_FIRST | MAL_RX_CTRL_LAST)) ==
-                            (MAL_RX_CTRL_FIRST | MAL_RX_CTRL_LAST)) {
-                                /* Single descriptor packet */
-                                emac_rx_csum(dev, ctrl, fep->rx_skb[i]);
-                                /* Send the skb up the chain. */
-                                frame_length = fep->rx_desc[i].data_len - 4;
-                                skb_put(fep->rx_skb[i], frame_length);
-                                fep->rx_skb[i]->dev = dev;
-                                fep->rx_skb[i]->protocol =
-                                    eth_type_trans(fep->rx_skb[i], dev);
-                                error = netif_rx(fep->rx_skb[i]);
-
-                                if ((error == NET_RX_DROP) ||
-                                    (error == NET_RX_BAD)) {
-                                        fep->stats.rx_dropped++;
-                                } else {
-                                        fep->stats.rx_packets++;
-                                        fep->stats.rx_bytes += frame_length;
-                                }
-                                fep->rx_skb[i] = NULL;
-                        } else {
-                                /* Multiple descriptor packet */
-                                if (ctrl & MAL_RX_CTRL_FIRST) {
-                                        if (fep->rx_desc[(i + 1) % NUM_RX_BUFF].
-                                            ctrl & MAL_RX_CTRL_EMPTY)
-                                                break;
-                                        bnum = 0;
-                                        buf[bnum] = i;
-                                        ++bnum;
-                                        continue;
-                                }
-                                if (((ctrl & MAL_RX_CTRL_FIRST) !=
-                                     MAL_RX_CTRL_FIRST) &&
-                                    ((ctrl & MAL_RX_CTRL_LAST) !=
-                                     MAL_RX_CTRL_LAST)) {
-                                        if (fep->rx_desc[(i + 1) %
-                                                         NUM_RX_BUFF].ctrl &
-                                            MAL_RX_CTRL_EMPTY) {
-                                                i = buf[0];
-                                                break;
-                                        }
-                                        buf[bnum] = i;
-                                        ++bnum;
-                                        continue;
-                                }
-                                if (ctrl & MAL_RX_CTRL_LAST) {
-                                        buf[bnum] = i;
-                                        ++bnum;
-                                        skb_put(fep->rx_skb[buf[0]],
-                                                fep->rx_desc[buf[0]].data_len);
-                                        for (b = 1; b < bnum; b++) {
-                                                /*
-                                                 * MAL is braindead, we need
-                                                 * to copy the remainder
-                                                 * of the packet from the
-                                                 * latter descriptor buffers
-                                                 * to the first skb. Then
-                                                 * dispose of the source
-                                                 * skbs.
-                                                 *
-                                                 * Once the stack is fixed
-                                                 * to handle frags on most
-                                                 * protocols we can generate
-                                                 * a fragmented skb with
-                                                 * no copies.
-                                                 */
-                                                memcpy(fep->rx_skb[buf[0]]->
-                                                       data +
-                                                       fep->rx_skb[buf[0]]->len,
-                                                       fep->rx_skb[buf[b]]->
-                                                       data,
-                                                       fep->rx_desc[buf[b]].
-                                                       data_len);
-                                                skb_put(fep->rx_skb[buf[0]],
-                                                        fep->rx_desc[buf[b]].
-                                                        data_len);
-                                                dma_unmap_single(&fep->ocpdev->
-                                                                 dev,
-                                                                 fep->
-                                                                 rx_desc[buf
-                                                                         [b]].
-                                                                 data_ptr,
-                                                                 fep->
-                                                                 rx_desc[buf
-                                                                         [b]].
-                                                                 data_len,
-                                                                 DMA_FROM_DEVICE);
-                                                dev_kfree_skb(fep->
-                                                              rx_skb[buf[b]]);
-                                        }
-                                        emac_rx_csum(dev, ctrl,
-                                                     fep->rx_skb[buf[0]]);
-
-                                        fep->rx_skb[buf[0]]->dev = dev;
-                                        fep->rx_skb[buf[0]]->protocol =
-                                            eth_type_trans(fep->rx_skb[buf[0]],
-                                                           dev);
-                                        error = netif_rx(fep->rx_skb[buf[0]]);
-
-                                        if ((error == NET_RX_DROP)
-                                            || (error == NET_RX_BAD)) {
-                                                fep->stats.rx_dropped++;
-                                        } else {
-                                                fep->stats.rx_packets++;
-                                                fep->stats.rx_bytes +=
-                                                    fep->rx_skb[buf[0]]->len;
-                                        }
-                                        for (b = 0; b < bnum; b++)
-                                                fep->rx_skb[buf[b]] = NULL;
-                                }
-                        }
+static void emac_clean_tx_ring(struct ocp_enet_private *dev)
+{
+        int i;
+        for (i = 0; i < NUM_TX_BUFF; ++i) {
+                if (dev->tx_skb[i]) {
+                        dev_kfree_skb(dev->tx_skb[i]);
+                        dev->tx_skb[i] = NULL;
+                        if (dev->tx_desc[i].ctrl & MAL_TX_CTRL_READY)
+                                ++dev->estats.tx_dropped;
                 }
-        } while ((i = (i + 1) % NUM_RX_BUFF) != fep->rx_slot);
-
-        PKT_DEBUG(("emac_rx_clean() exit, rx_slot: %d\n", fep->rx_slot));
-
-        return i;
+                dev->tx_desc[i].ctrl = 0;
+                dev->tx_desc[i].data_ptr = 0;
+        }
 }
 
-static void emac_rxeob_dev(void *param, u32 chanmask)
+static void emac_clean_rx_ring(struct ocp_enet_private *dev)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long flags;
-        int n;
+        int i;
+        for (i = 0; i < NUM_RX_BUFF; ++i)
+                if (dev->rx_skb[i]) {
+                        dev->rx_desc[i].ctrl = 0;
+                        dev_kfree_skb(dev->rx_skb[i]);
+                        dev->rx_skb[i] = NULL;
+                        dev->rx_desc[i].data_ptr = 0;
+                }
 
-        spin_lock_irqsave(&fep->lock, flags);
-        if ((n = emac_rx_clean(dev)) != fep->rx_slot)
-                emac_rx_fill(dev, n);
-        spin_unlock_irqrestore(&fep->lock, flags);
+        if (dev->rx_sg_skb) {
+                dev_kfree_skb(dev->rx_sg_skb);
+                dev->rx_sg_skb = NULL;
+        }
 }
 
-/*
- * This interrupt should never occurr, we don't program
- * the MAL for contiunous mode.
- */
-static void emac_txde_dev(void *param, u32 chanmask)
+static inline int emac_alloc_rx_skb(struct ocp_enet_private *dev, int slot,
+                                    int flags)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
+        struct sk_buff *skb = alloc_skb(dev->rx_skb_size, flags);
+        if (unlikely(!skb))
+                return -ENOMEM;
 
-        printk(KERN_WARNING "%s: transmit descriptor error\n", dev->name);
+        dev->rx_skb[slot] = skb;
+        dev->rx_desc[slot].data_len = 0;
 
-        emac_mac_dump(dev);
-        emac_mal_dump(dev);
+        skb_reserve(skb, EMAC_RX_SKB_HEADROOM + 2);
+        dev->rx_desc[slot].data_ptr = 
+            dma_map_single(dev->ldev, skb->data - 2, dev->rx_sync_size, 
+                           DMA_FROM_DEVICE) + 2;
+        barrier();
+        dev->rx_desc[slot].ctrl = MAL_RX_CTRL_EMPTY |
+            (slot == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
 
-        /* Reenable the transmit channel */
-        mal_enable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
+        return 0;
 }
 
-/*
- * This interrupt should be very rare at best.  This occurs when
- * the hardware has a problem with the receive descriptors.  The manual
- * states that it occurs when the hardware cannot the receive descriptor
- * empty bit is not set.  The recovery mechanism will be to
- * traverse through the descriptors, handle any that are marked to be
- * handled and reinitialize each along the way.  At that point the driver
- * will be restarted.
- */
-static void emac_rxde_dev(void *param, u32 chanmask)
+static void emac_print_link_status(struct ocp_enet_private *dev)
 {
-        struct net_device *dev = param;
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long flags;
-
-        if (net_ratelimit()) {
-                printk(KERN_WARNING "%s: receive descriptor error\n",
-                       fep->ndev->name);
+        if (netif_carrier_ok(dev->ndev))
+                printk(KERN_INFO "%s: link is up, %d %s%s\n",
+                       dev->ndev->name, dev->phy.speed,
+                       dev->phy.duplex == DUPLEX_FULL ? "FDX" : "HDX",
+                       dev->phy.pause ? ", pause enabled" :
+                       dev->phy.asym_pause ? ", assymetric pause enabled" : "");
+        else
+                printk(KERN_INFO "%s: link is down\n", dev->ndev->name);
+}
 
-                emac_mac_dump(dev);
-                emac_mal_dump(dev);
-                emac_desc_dump(dev);
+/* Process ctx, rtnl_lock semaphore */
+static int emac_open(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+        int err, i;
+
+        DBG("%d: open" NL, dev->def->index);
+
+        /* Setup error IRQ handler */
+        err = request_irq(dev->def->irq, emac_irq, 0, "EMAC", dev);
+        if (err) {
+                printk(KERN_ERR "%s: failed to request IRQ %d\n",
+                       ndev->name, dev->def->irq);
+                return err;
         }
 
-        /* Disable RX channel */
-        spin_lock_irqsave(&fep->lock, flags);
-        mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-
-        /* For now, charge the error against all emacs */
-        fep->stats.rx_errors++;
-
-        /* so do we have any good packets still? */
-        emac_rx_clean(dev);
-
-        /* When the interface is restarted it resets processing to the
-         *  first descriptor in the table.
-         */
-
-        fep->rx_slot = 0;
-        emac_rx_fill(dev, 0);
+        /* Allocate RX ring */
+        for (i = 0; i < NUM_RX_BUFF; ++i)
+                if (emac_alloc_rx_skb(dev, i, GFP_KERNEL)) {
+                        printk(KERN_ERR "%s: failed to allocate RX ring\n",
+                               ndev->name);
+                        goto oom;
+                }
 
-        set_mal_dcrn(fep->mal, DCRN_MALRXEOBISR, fep->commac.rx_chan_mask);
-        set_mal_dcrn(fep->mal, DCRN_MALRXDEIR, fep->commac.rx_chan_mask);
+        local_bh_disable();
+        dev->tx_cnt = dev->tx_slot = dev->ack_slot = dev->rx_slot =
+            dev->commac.rx_stopped = 0;
+        dev->rx_sg_skb = NULL;
+
+        if (dev->phy.address >= 0) {
+                int link_poll_interval;
+                if (dev->phy.def->ops->poll_link(&dev->phy)) {
+                        dev->phy.def->ops->read_link(&dev->phy);
+                        EMAC_RX_CLK_DEFAULT(dev->def->index);
+                        netif_carrier_on(dev->ndev);
+                        link_poll_interval = PHY_POLL_LINK_ON;
+                } else {
+                        EMAC_RX_CLK_TX(dev->def->index);
+                        netif_carrier_off(dev->ndev);
+                        link_poll_interval = PHY_POLL_LINK_OFF;
+                }
+                mod_timer(&dev->link_timer, jiffies + link_poll_interval);
+                emac_print_link_status(dev);
+        } else
+                netif_carrier_on(dev->ndev);
+
+        emac_configure(dev);
+        mal_poll_add(dev->mal, &dev->commac);
+        mal_enable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        mal_set_rcbs(dev->mal, emacdata->mal_rx_chan, emac_rx_size(ndev->mtu));
+        mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+        emac_tx_enable(dev);
+        emac_rx_enable(dev);
+        netif_start_queue(ndev);
+        local_bh_enable();
 
-        /* Reenable the receive channels */
-        mal_enable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-        spin_unlock_irqrestore(&fep->lock, flags);
+        return 0;
+      oom:
+        emac_clean_rx_ring(dev);
+        free_irq(dev->def->irq, dev);
+        return -ENOMEM;
 }
 
-static irqreturn_t
-emac_mac_irq(int irq, void *dev_instance, struct pt_regs *regs)
+/* BHs disabled */
+static int emac_link_differs(struct ocp_enet_private *dev)
 {
-        struct net_device *dev = dev_instance;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
-        unsigned long tmp_em0isr;
+        u32 r = in_be32(&dev->emacp->mr1);
 
-        /* EMAC interrupt */
-        tmp_em0isr = in_be32(&emacp->em0isr);
-        if (tmp_em0isr & (EMAC_ISR_TE0 | EMAC_ISR_TE1)) {
-                /* This error is a hard transmit error - could retransmit */
-                fep->stats.tx_errors++;
+        int duplex = r & EMAC_MR1_FDE ? DUPLEX_FULL : DUPLEX_HALF;
+        int speed, pause, asym_pause;
 
-                /* Reenable the transmit channel */
-                mal_enable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
+        if (r & (EMAC_MR1_MF_1000 | EMAC_MR1_MF_1000GPCS))
+                speed = SPEED_1000;
+        else if (r & EMAC_MR1_MF_100)
+                speed = SPEED_100;
+        else
+                speed = SPEED_10;
 
-        } else {
-                fep->stats.rx_errors++;
+        switch (r & (EMAC_MR1_EIFC | EMAC_MR1_APP)) {
+        case (EMAC_MR1_EIFC | EMAC_MR1_APP):
+                pause = 1;
+                asym_pause = 0;
+                break;
+        case EMAC_MR1_APP:
+                pause = 0;
+                asym_pause = 1;
+                break;
+        default:
+                pause = asym_pause = 0;
         }
-
-        if (tmp_em0isr & EMAC_ISR_RP)
-                fep->stats.rx_length_errors++;
-        if (tmp_em0isr & EMAC_ISR_ALE)
-                fep->stats.rx_frame_errors++;
-        if (tmp_em0isr & EMAC_ISR_BFCS)
-                fep->stats.rx_crc_errors++;
-        if (tmp_em0isr & EMAC_ISR_PTLE)
-                fep->stats.rx_length_errors++;
-        if (tmp_em0isr & EMAC_ISR_ORE)
-                fep->stats.rx_length_errors++;
-        if (tmp_em0isr & EMAC_ISR_TE0)
-                fep->stats.tx_aborted_errors++;
-
-        emac_err_dump(dev, tmp_em0isr);
-
-        out_be32(&emacp->em0isr, tmp_em0isr);
-
-        return IRQ_HANDLED;
+        return speed != dev->phy.speed || duplex != dev->phy.duplex ||
+            pause != dev->phy.pause || asym_pause != dev->phy.asym_pause;
 }
 
-static int emac_start_xmit(struct sk_buff *skb, struct net_device *dev)
+/* BHs disabled */
+static void emac_link_timer(unsigned long data)
 {
-        unsigned short ctrl;
-        unsigned long flags;
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
-        int len = skb->len;
-        unsigned int offset = 0, size, f, tx_slot_first;
-        unsigned int nr_frags = skb_shinfo(skb)->nr_frags;
+        struct ocp_enet_private *dev = (struct ocp_enet_private *)data;
+        int link_poll_interval;
 
-        spin_lock_irqsave(&fep->lock, flags);
+        DBG2("%d: link timer" NL, dev->def->index);
 
-        len -= skb->data_len;
+        if (dev->phy.def->ops->poll_link(&dev->phy)) {
+                if (!netif_carrier_ok(dev->ndev)) {
+                        EMAC_RX_CLK_DEFAULT(dev->def->index);
 
-        if ((fep->tx_cnt + nr_frags + len / DESC_BUF_SIZE + 1) > NUM_TX_BUFF) {
-                PKT_DEBUG(("emac_start_xmit() stopping queue\n"));
-                netif_stop_queue(dev);
-                spin_unlock_irqrestore(&fep->lock, flags);
-                return -EBUSY;
-        }
+                        /* Get new link parameters */
+                        dev->phy.def->ops->read_link(&dev->phy);
 
-        tx_slot_first = fep->tx_slot;
+                        if (dev->tah_dev || emac_link_differs(dev))
+                                emac_full_tx_reset(dev->ndev);
 
-        while (len) {
-                size = min(len, DESC_BUF_SIZE);
-
-                fep->tx_desc[fep->tx_slot].data_len = (short)size;
-                fep->tx_desc[fep->tx_slot].data_ptr =
-                    (unsigned char *)dma_map_single(&fep->ocpdev->dev,
-                                                    (void *)((unsigned int)skb->
-                                                             data + offset),
-                                                    size, DMA_TO_DEVICE);
-
-                ctrl = EMAC_TX_CTRL_DFLT;
-                if (fep->tx_slot != tx_slot_first)
-                        ctrl |= MAL_TX_CTRL_READY;
-                if ((NUM_TX_BUFF - 1) == fep->tx_slot)
-                        ctrl |= MAL_TX_CTRL_WRAP;
-                if (!nr_frags && (len == size)) {
-                        ctrl |= MAL_TX_CTRL_LAST;
-                        fep->tx_skb[fep->tx_slot] = skb;
+                        netif_carrier_on(dev->ndev);
+                        emac_print_link_status(dev);
+                }
+                link_poll_interval = PHY_POLL_LINK_ON;
+        } else {
+                if (netif_carrier_ok(dev->ndev)) {
+                        EMAC_RX_CLK_TX(dev->def->index);
+#if defined(CONFIG_IBM_EMAC_PHY_RX_CLK_FIX)
+                        emac_reinitialize(dev);
+#endif
+                        netif_carrier_off(dev->ndev);
+                        emac_print_link_status(dev);
                 }
-                if (skb->ip_summed == CHECKSUM_HW)
-                        ctrl |= EMAC_TX_CTRL_TAH_CSUM;
 
-                fep->tx_desc[fep->tx_slot].ctrl = ctrl;
+                /* Retry reset if the previous attempt failed.
+                 * This is needed mostly for CONFIG_IBM_EMAC_PHY_RX_CLK_FIX
+                 * case, but I left it here because it shouldn't trigger for
+                 * sane PHYs anyway.
+                 */
+                if (unlikely(dev->reset_failed))
+                        emac_reinitialize(dev);
 
-                len -= size;
-                offset += size;
+                link_poll_interval = PHY_POLL_LINK_OFF;
+        }
+        mod_timer(&dev->link_timer, jiffies + link_poll_interval);
+}
 
-                /* Bump tx count */
-                if (++fep->tx_cnt == NUM_TX_BUFF)
-                        netif_stop_queue(dev);
+/* BHs disabled */
+static void emac_force_link_update(struct ocp_enet_private *dev)
+{
+        netif_carrier_off(dev->ndev);
+        if (timer_pending(&dev->link_timer))
+                mod_timer(&dev->link_timer, jiffies + PHY_POLL_LINK_OFF);
+}
 
-                /* Next descriptor */
-                if (++fep->tx_slot == NUM_TX_BUFF)
-                        fep->tx_slot = 0;
-        }
+/* Process ctx, rtnl_lock semaphore */
+static int emac_close(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
 
-        for (f = 0; f < nr_frags; f++) {
-                struct skb_frag_struct *frag;
+        DBG("%d: close" NL, dev->def->index);
 
-                frag = &skb_shinfo(skb)->frags[f];
-                len = frag->size;
-                offset = 0;
-
-                while (len) {
-                        size = min(len, DESC_BUF_SIZE);
-
-                        dma_map_page(&fep->ocpdev->dev,
-                                     frag->page,
-                                     frag->page_offset + offset,
-                                     size, DMA_TO_DEVICE);
-
-                        ctrl = EMAC_TX_CTRL_DFLT | MAL_TX_CTRL_READY;
-                        if ((NUM_TX_BUFF - 1) == fep->tx_slot)
-                                ctrl |= MAL_TX_CTRL_WRAP;
-                        if ((f == (nr_frags - 1)) && (len == size)) {
-                                ctrl |= MAL_TX_CTRL_LAST;
-                                fep->tx_skb[fep->tx_slot] = skb;
-                        }
+        local_bh_disable();
 
-                        if (skb->ip_summed == CHECKSUM_HW)
-                                ctrl |= EMAC_TX_CTRL_TAH_CSUM;
+        if (dev->phy.address >= 0)
+                del_timer_sync(&dev->link_timer);
 
-                        fep->tx_desc[fep->tx_slot].data_len = (short)size;
-                        fep->tx_desc[fep->tx_slot].data_ptr =
-                            (char *)((page_to_pfn(frag->page) << PAGE_SHIFT) +
-                                     frag->page_offset + offset);
-                        fep->tx_desc[fep->tx_slot].ctrl = ctrl;
+        netif_stop_queue(ndev);
+        emac_rx_disable(dev);
+        emac_tx_disable(dev);
+        mal_disable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+        mal_disable_tx_channel(dev->mal, emacdata->mal_tx_chan);
+        mal_poll_del(dev->mal, &dev->commac);
+        local_bh_enable();
 
-                        len -= size;
-                        offset += size;
+        emac_clean_tx_ring(dev);
+        emac_clean_rx_ring(dev);
+        free_irq(dev->def->irq, dev);
 
-                        /* Bump tx count */
-                        if (++fep->tx_cnt == NUM_TX_BUFF)
-                                netif_stop_queue(dev);
+        return 0;
+}
 
-                        /* Next descriptor */
-                        if (++fep->tx_slot == NUM_TX_BUFF)
-                                fep->tx_slot = 0;
-                }
+static inline u16 emac_tx_csum(struct ocp_enet_private *dev,
+                               struct sk_buff *skb)
+{
+#if defined(CONFIG_IBM_EMAC_TAH)
+        if (skb->ip_summed == CHECKSUM_HW) {
+                ++dev->stats.tx_packets_csum;
+                return EMAC_TX_CTRL_TAH_CSUM;
         }
+#endif
+        return 0;
+}
 
-        /*
-         * Deferred set READY on first descriptor of packet to
-         * avoid TX MAL race.
-         */
-        fep->tx_desc[tx_slot_first].ctrl |= MAL_TX_CTRL_READY;
-
-        /* Send the packet out. */
-        out_be32(&emacp->em0tmr0, EMAC_TMR0_XMIT);
+static inline int emac_xmit_finish(struct ocp_enet_private *dev, int len)
+{
+        struct emac_regs *p = dev->emacp;
+        struct net_device *ndev = dev->ndev;
 
-        fep->stats.tx_packets++;
-        fep->stats.tx_bytes += skb->len;
+        /* Send the packet out */
+        out_be32(&p->tmr0, EMAC_TMR0_XMIT);
 
-        PKT_DEBUG(("emac_start_xmit() exitn"));
+        if (unlikely(++dev->tx_cnt == NUM_TX_BUFF)) {
+                netif_stop_queue(ndev);
+                DBG2("%d: stopped TX queue" NL, dev->def->index);
+        }
 
-        spin_unlock_irqrestore(&fep->lock, flags);
+        ndev->trans_start = jiffies;
+        ++dev->stats.tx_packets;
+        dev->stats.tx_bytes += len;
 
         return 0;
 }
 
-static int emac_adjust_to_link(struct ocp_enet_private *fep)
+/* BHs disabled */
+static int emac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 {
-        emac_t *emacp = fep->emacp;
-        unsigned long mode_reg;
-        int full_duplex, speed;
+        struct ocp_enet_private *dev = ndev->priv;
+        unsigned int len = skb->len;
+        int slot;
 
-        full_duplex = 0;
-        speed = SPEED_10;
+        u16 ctrl = EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP | MAL_TX_CTRL_READY |
+            MAL_TX_CTRL_LAST | emac_tx_csum(dev, skb);
 
-        /* set mode register 1 defaults */
-        mode_reg = EMAC_M1_DEFAULT;
-
-        /* Read link mode on PHY */
-        if (fep->phy_mii.def->ops->read_link(&fep->phy_mii) == 0) {
-                /* If an error occurred, we don't deal with it yet */
-                full_duplex = (fep->phy_mii.duplex == DUPLEX_FULL);
-                speed = fep->phy_mii.speed;
+        slot = dev->tx_slot++;
+        if (dev->tx_slot == NUM_TX_BUFF) {
+                dev->tx_slot = 0;
+                ctrl |= MAL_TX_CTRL_WRAP;
         }
 
+        DBG2("%d: xmit(%u) %d" NL, dev->def->index, len, slot);
 
-        /* set speed (default is 10Mb) */
-        switch (speed) {
-        case SPEED_1000:
-                mode_reg |= EMAC_M1_RFS_16K;
-                if (fep->rgmii_dev) {
-                        struct ibm_ocp_rgmii *rgmii = RGMII_PRIV(fep->rgmii_dev);
-
-                        if ((rgmii->mode[fep->rgmii_input] == RTBI)
-                            || (rgmii->mode[fep->rgmii_input] == TBI))
-                                mode_reg |= EMAC_M1_MF_1000GPCS;
-                        else
-                                mode_reg |= EMAC_M1_MF_1000MBPS;
-
-                        emac_rgmii_port_speed(fep->rgmii_dev, fep->rgmii_input,
-                                              1000);
-                }
-                break;
-        case SPEED_100:
-                mode_reg |= EMAC_M1_MF_100MBPS | EMAC_M1_RFS_4K;
-                if (fep->rgmii_dev)
-                        emac_rgmii_port_speed(fep->rgmii_dev, fep->rgmii_input,
-                                              100);
-                if (fep->zmii_dev)
-                        emac_zmii_port_speed(fep->zmii_dev, fep->zmii_input,
-                                             100);
-                break;
-        case SPEED_10:
-        default:
-                mode_reg = (mode_reg & ~EMAC_M1_MF_100MBPS) | EMAC_M1_RFS_4K;
-                if (fep->rgmii_dev)
-                        emac_rgmii_port_speed(fep->rgmii_dev, fep->rgmii_input,
-                                              10);
-                if (fep->zmii_dev)
-                        emac_zmii_port_speed(fep->zmii_dev, fep->zmii_input,
-                                             10);
-        }
-
-        if (full_duplex)
-                mode_reg |= EMAC_M1_FDE | EMAC_M1_EIFC | EMAC_M1_IST;
-        else
-                mode_reg &= ~(EMAC_M1_FDE | EMAC_M1_EIFC | EMAC_M1_ILE);
+        dev->tx_skb[slot] = skb;
+        dev->tx_desc[slot].data_ptr = dma_map_single(dev->ldev, skb->data, len,
+                                                     DMA_TO_DEVICE);
+        dev->tx_desc[slot].data_len = (u16) len;
+        barrier();
+        dev->tx_desc[slot].ctrl = ctrl;
 
-        LINK_DEBUG(("%s: adjust to link, speed: %d, duplex: %d, opened: %d\n",
-                    fep->ndev->name, speed, full_duplex, fep->opened));
-
-        printk(KERN_INFO "%s: Speed: %d, %s duplex.\n",
-               fep->ndev->name, speed, full_duplex ? "Full" : "Half");
-        if (fep->opened)
-                out_be32(&emacp->em0mr1, mode_reg);
-
-        return 0;
+        return emac_xmit_finish(dev, len);
 }
 
-static int emac_set_mac_address(struct net_device *ndev, void *p)
+#if defined(CONFIG_IBM_EMAC_TAH)
+static inline int emac_xmit_split(struct ocp_enet_private *dev, int slot,
+                                  u32 pd, int len, int last, u16 base_ctrl)
 {
-        struct ocp_enet_private *fep = ndev->priv;
-        emac_t *emacp = fep->emacp;
-        struct sockaddr *addr = p;
+        while (1) {
+                u16 ctrl = base_ctrl;
+                int chunk = min(len, MAL_MAX_TX_SIZE);
+                len -= chunk;
 
-        if (!is_valid_ether_addr(addr->sa_data))
-                return -EADDRNOTAVAIL;
+                slot = (slot + 1) % NUM_TX_BUFF;
 
-        memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+                if (last && !len)
+                        ctrl |= MAL_TX_CTRL_LAST;
+                if (slot == NUM_TX_BUFF - 1)
+                        ctrl |= MAL_TX_CTRL_WRAP;
 
-        /* set the high address */
-        out_be32(&emacp->em0iahr,
-                 (fep->ndev->dev_addr[0] << 8) | fep->ndev->dev_addr[1]);
+                dev->tx_skb[slot] = NULL;
+                dev->tx_desc[slot].data_ptr = pd;
+                dev->tx_desc[slot].data_len = (u16) chunk;
+                dev->tx_desc[slot].ctrl = ctrl;
+                ++dev->tx_cnt;
 
-        /* set the low address */
-        out_be32(&emacp->em0ialr,
-                 (fep->ndev->dev_addr[2] << 24) | (fep->ndev->dev_addr[3] << 16)
-                 | (fep->ndev->dev_addr[4] << 8) | fep->ndev->dev_addr[5]);
+                if (!len)
+                        break;
 
-        return 0;
+                pd += chunk;
+        }
+        return slot;
 }
 
-static int emac_change_mtu(struct net_device *dev, int new_mtu)
+/* BHs disabled (SG version for TAH equipped EMACs) */
+static int emac_start_xmit_sg(struct sk_buff *skb, struct net_device *ndev)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        int old_mtu = dev->mtu;
-        unsigned long mode_reg;
-        emac_t *emacp = fep->emacp;
-        u32 em0mr0;
-        int i, full;
-        unsigned long flags;
+        struct ocp_enet_private *dev = ndev->priv;
+        int nr_frags = skb_shinfo(skb)->nr_frags;
+        int len = skb->len, chunk;
+        int slot, i;
+        u16 ctrl;
+        u32 pd;
 
-        if ((new_mtu < EMAC_MIN_MTU) || (new_mtu > EMAC_MAX_MTU)) {
-                printk(KERN_ERR
-                       "emac: Invalid MTU setting, MTU must be between %d and %d\n",
-                       EMAC_MIN_MTU, EMAC_MAX_MTU);
-                return -EINVAL;
-        }
+        /* This is common "fast" path */
+        if (likely(!nr_frags && len <= MAL_MAX_TX_SIZE))
+                return emac_start_xmit(skb, ndev);
 
-        if (old_mtu != new_mtu && netif_running(dev)) {
-                /* Stop rx engine */
-                em0mr0 = in_be32(&emacp->em0mr0);
-                out_be32(&emacp->em0mr0, em0mr0 & ~EMAC_M0_RXE);
-
-                /* Wait for descriptors to be empty */
-                do {
-                        full = 0;
-                        for (i = 0; i < NUM_RX_BUFF; i++)
-                                if (!(fep->rx_desc[i].ctrl & MAL_RX_CTRL_EMPTY)) {
-                                        printk(KERN_NOTICE
-                                               "emac: RX ring is still full\n");
-                                        full = 1;
-                                }
-                } while (full);
-
-                spin_lock_irqsave(&fep->lock, flags);
-
-                mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-
-                /* Destroy all old rx skbs */
-                for (i = 0; i < NUM_RX_BUFF; i++) {
-                        dma_unmap_single(&fep->ocpdev->dev,
-                                         fep->rx_desc[i].data_ptr,
-                                         fep->rx_desc[i].data_len,
-                                         DMA_FROM_DEVICE);
-                        dev_kfree_skb(fep->rx_skb[i]);
-                        fep->rx_skb[i] = NULL;
-                }
+        len -= skb->data_len;
 
-                /* Set new rx_buffer_size, jumbo cap, and advertise new mtu */
-                mode_reg = in_be32(&emacp->em0mr1);
-                if (new_mtu > ENET_DEF_MTU_SIZE) {
-                        mode_reg |= EMAC_M1_JUMBO_ENABLE;
-                        fep->rx_buffer_size = EMAC_MAX_FRAME;
-                } else {
-                        mode_reg &= ~EMAC_M1_JUMBO_ENABLE;
-                        fep->rx_buffer_size = ENET_DEF_BUF_SIZE;
-                }
-                dev->mtu = new_mtu;
-                out_be32(&emacp->em0mr1, mode_reg);
+        /* Note, this is only an *estimation*, we can still run out of empty
+         * slots because of the additional fragmentation into
+         * MAL_MAX_TX_SIZE-sized chunks
+         */
+        if (unlikely(dev->tx_cnt + nr_frags + mal_tx_chunks(len) > NUM_TX_BUFF))
+                goto stop_queue;
+
+        ctrl = EMAC_TX_CTRL_GFCS | EMAC_TX_CTRL_GP | MAL_TX_CTRL_READY |
+            emac_tx_csum(dev, skb);
+        slot = dev->tx_slot;
+
+        /* skb data */
+        dev->tx_skb[slot] = NULL;
+        chunk = min(len, MAL_MAX_TX_SIZE);
+        dev->tx_desc[slot].data_ptr = pd =
+            dma_map_single(dev->ldev, skb->data, len, DMA_TO_DEVICE);
+        dev->tx_desc[slot].data_len = (u16) chunk;
+        len -= chunk;
+        if (unlikely(len))
+                slot = emac_xmit_split(dev, slot, pd + chunk, len, !nr_frags,
+                                       ctrl);
+        /* skb fragments */
+        for (i = 0; i < nr_frags; ++i) {
+                struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
+                len = frag->size;
 
-                /* Re-init rx skbs */
-                fep->rx_slot = 0;
-                emac_rx_fill(dev, 0);
+                if (unlikely(dev->tx_cnt + mal_tx_chunks(len) >= NUM_TX_BUFF))
+                        goto undo_frame;
 
-                /* Restart the rx engine */
-                mal_enable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-                out_be32(&emacp->em0mr0, em0mr0 | EMAC_M0_RXE);
+                pd = dma_map_page(dev->ldev, frag->page, frag->page_offset, len,
+                                  DMA_TO_DEVICE);
 
-                spin_unlock_irqrestore(&fep->lock, flags);
+                slot = emac_xmit_split(dev, slot, pd, len, i == nr_frags - 1,
+                                       ctrl);
         }
 
-        return 0;
-}
+        DBG2("%d: xmit_sg(%u) %d - %d" NL, dev->def->index, skb->len,
+             dev->tx_slot, slot);
 
-static void __emac_set_multicast_list(struct net_device *dev)
-{
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
-        u32 rmr = in_be32(&emacp->em0rmr);
+        /* Attach skb to the last slot so we don't release it too early */
+        dev->tx_skb[slot] = skb;
 
-        /* First clear all special bits, they can be set later */
-        rmr &= ~(EMAC_RMR_PME | EMAC_RMR_PMME | EMAC_RMR_MAE);
+        /* Send the packet out */
+        if (dev->tx_slot == NUM_TX_BUFF - 1)
+                ctrl |= MAL_TX_CTRL_WRAP;
+        barrier();
+        dev->tx_desc[dev->tx_slot].ctrl = ctrl;
+        dev->tx_slot = (slot + 1) % NUM_TX_BUFF;
 
-        if (dev->flags & IFF_PROMISC) {
-                rmr |= EMAC_RMR_PME;
-        } else if (dev->flags & IFF_ALLMULTI || 32 < dev->mc_count) {
-                /*
-                 * Must be setting up to use multicast
-                 * Now check for promiscuous multicast
-                 */
-                rmr |= EMAC_RMR_PMME;
-        } else if (dev->flags & IFF_MULTICAST && 0 < dev->mc_count) {
-                unsigned short em0gaht[4] = { 0, 0, 0, 0 };
-                struct dev_mc_list *dmi;
-
-                /* Need to hash on the multicast address. */
-                for (dmi = dev->mc_list; dmi; dmi = dmi->next) {
-                        unsigned long mc_crc;
-                        unsigned int bit_number;
-
-                        mc_crc = ether_crc(6, (char *)dmi->dmi_addr);
-                        bit_number = 63 - (mc_crc >> 26);       /* MSB: 0 LSB: 63 */
-                        em0gaht[bit_number >> 4] |=
-                            0x8000 >> (bit_number & 0x0f);
-                }
-                emacp->em0gaht1 = em0gaht[0];
-                emacp->em0gaht2 = em0gaht[1];
-                emacp->em0gaht3 = em0gaht[2];
-                emacp->em0gaht4 = em0gaht[3];
+        return emac_xmit_finish(dev, skb->len);
 
-                /* Turn on multicast addressing */
-                rmr |= EMAC_RMR_MAE;
+      undo_frame:
+        /* Well, too bad. Our previous estimation was overly optimistic. 
+         * Undo everything.
+         */
+        while (slot != dev->tx_slot) {
+                dev->tx_desc[slot].ctrl = 0;
+                --dev->tx_cnt;
+                if (--slot < 0)
+                        slot = NUM_TX_BUFF - 1;
         }
-        out_be32(&emacp->em0rmr, rmr);
+        ++dev->estats.tx_undo;
+
+      stop_queue:
+        netif_stop_queue(ndev);
+        DBG2("%d: stopped TX queue" NL, dev->def->index);
+        return 1;
 }
+#else
+# define emac_start_xmit_sg     emac_start_xmit
+#endif  /* !defined(CONFIG_IBM_EMAC_TAH) */
 
-static int emac_init_tah(struct ocp_enet_private *fep)
+/* BHs disabled */
+static void emac_parse_tx_error(struct ocp_enet_private *dev, u16 ctrl)
 {
-        tah_t *tahp;
+        struct ibm_emac_error_stats *st = &dev->estats;
+        DBG("%d: BD TX error %04x" NL, dev->def->index, ctrl);
+
+        ++st->tx_bd_errors;
+        if (ctrl & EMAC_TX_ST_BFCS)
+                ++st->tx_bd_bad_fcs;
+        if (ctrl & EMAC_TX_ST_LCS)
+                ++st->tx_bd_carrier_loss;
+        if (ctrl & EMAC_TX_ST_ED)
+                ++st->tx_bd_excessive_deferral;
+        if (ctrl & EMAC_TX_ST_EC)
+                ++st->tx_bd_excessive_collisions;
+        if (ctrl & EMAC_TX_ST_LC)
+                ++st->tx_bd_late_collision;
+        if (ctrl & EMAC_TX_ST_MC)
+                ++st->tx_bd_multple_collisions;
+        if (ctrl & EMAC_TX_ST_SC)
+                ++st->tx_bd_single_collision;
+        if (ctrl & EMAC_TX_ST_UR)
+                ++st->tx_bd_underrun;
+        if (ctrl & EMAC_TX_ST_SQE)
+                ++st->tx_bd_sqe;
+}
 
-        /* Initialize TAH and enable checksum verification */
-        tahp = (tah_t *) ioremap(fep->tah_dev->def->paddr, sizeof(*tahp));
+static void emac_poll_tx(void *param)
+{
+        struct ocp_enet_private *dev = param;
+        DBG2("%d: poll_tx, %d %d" NL, dev->def->index, dev->tx_cnt,
+             dev->ack_slot);
+
+        if (dev->tx_cnt) {
+                u16 ctrl;
+                int slot = dev->ack_slot, n = 0;
+              again:
+                ctrl = dev->tx_desc[slot].ctrl;
+                if (!(ctrl & MAL_TX_CTRL_READY)) {
+                        struct sk_buff *skb = dev->tx_skb[slot];
+                        ++n;
+
+                        if (skb) {
+                                dev_kfree_skb(skb);
+                                dev->tx_skb[slot] = NULL;
+                        }
+                        slot = (slot + 1) % NUM_TX_BUFF;
 
-        if (tahp == NULL) {
-                printk(KERN_ERR "tah%d: Cannot ioremap TAH registers!\n",
-                       fep->tah_dev->def->index);
+                        if (unlikely(EMAC_IS_BAD_TX(ctrl)))
+                                emac_parse_tx_error(dev, ctrl);
 
-                return -ENOMEM;
-        }
-
-        out_be32(&tahp->tah_mr, TAH_MR_SR);
+                        if (--dev->tx_cnt)
+                                goto again;
+                }
+                if (n) {
+                        dev->ack_slot = slot;
+                        if (netif_queue_stopped(dev->ndev) &&
+                            dev->tx_cnt < EMAC_TX_WAKEUP_THRESH)
+                                netif_wake_queue(dev->ndev);
 
-        /* wait for reset to complete */
-        while (in_be32(&tahp->tah_mr) & TAH_MR_SR) ;
+                        DBG2("%d: tx %d pkts" NL, dev->def->index, n);
+                }
+        }
+}
 
-        /* 10KB TAH TX FIFO accomodates the max MTU of 9000 */
-        out_be32(&tahp->tah_mr,
-                 TAH_MR_CVR | TAH_MR_ST_768 | TAH_MR_TFS_10KB | TAH_MR_DTFP |
-                 TAH_MR_DIG);
+static inline void emac_recycle_rx_skb(struct ocp_enet_private *dev, int slot,
+                                       int len)
+{
+        struct sk_buff *skb = dev->rx_skb[slot];
+        DBG2("%d: recycle %d %d" NL, dev->def->index, slot, len);
 
-        iounmap(tahp);
+        if (len) 
+                dma_map_single(dev->ldev, skb->data - 2, 
+                               EMAC_DMA_ALIGN(len + 2), DMA_FROM_DEVICE);
 
-        return 0;
+        dev->rx_desc[slot].data_len = 0;
+        barrier();
+        dev->rx_desc[slot].ctrl = MAL_RX_CTRL_EMPTY |
+            (slot == (NUM_RX_BUFF - 1) ? MAL_RX_CTRL_WRAP : 0);
 }
 
-static void emac_init_rings(struct net_device *dev)
+static void emac_parse_rx_error(struct ocp_enet_private *dev, u16 ctrl)
 {
-        struct ocp_enet_private *ep = dev->priv;
-        int loop;
+        struct ibm_emac_error_stats *st = &dev->estats;
+        DBG("%d: BD RX error %04x" NL, dev->def->index, ctrl);
+
+        ++st->rx_bd_errors;
+        if (ctrl & EMAC_RX_ST_OE)
+                ++st->rx_bd_overrun;
+        if (ctrl & EMAC_RX_ST_BP)
+                ++st->rx_bd_bad_packet;
+        if (ctrl & EMAC_RX_ST_RP)
+                ++st->rx_bd_runt_packet;
+        if (ctrl & EMAC_RX_ST_SE)
+                ++st->rx_bd_short_event;
+        if (ctrl & EMAC_RX_ST_AE)
+                ++st->rx_bd_alignment_error;
+        if (ctrl & EMAC_RX_ST_BFCS)
+                ++st->rx_bd_bad_fcs;
+        if (ctrl & EMAC_RX_ST_PTL)
+                ++st->rx_bd_packet_too_long;
+        if (ctrl & EMAC_RX_ST_ORE)
+                ++st->rx_bd_out_of_range;
+        if (ctrl & EMAC_RX_ST_IRE)
+                ++st->rx_bd_in_range;
+}
 
-        ep->tx_desc = (struct mal_descriptor *)((char *)ep->mal->tx_virt_addr +
-                                                (ep->mal_tx_chan *
-                                                 MAL_DT_ALIGN));
-        ep->rx_desc =
-            (struct mal_descriptor *)((char *)ep->mal->rx_virt_addr +
-                                      (ep->mal_rx_chan * MAL_DT_ALIGN));
+static inline void emac_rx_csum(struct ocp_enet_private *dev,
+                                struct sk_buff *skb, u16 ctrl)
+{
+#if defined(CONFIG_IBM_EMAC_TAH)
+        if (!ctrl && dev->tah_dev) {
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+                ++dev->stats.rx_packets_csum;
+        }
+#endif
+}
 
-        /* Fill in the transmit descriptor ring. */
-        for (loop = 0; loop < NUM_TX_BUFF; loop++) {
-                if (ep->tx_skb[loop]) {
-                        dma_unmap_single(&ep->ocpdev->dev,
-                                         ep->tx_desc[loop].data_ptr,
-                                         ep->tx_desc[loop].data_len,
-                                         DMA_TO_DEVICE);
-                        dev_kfree_skb_irq(ep->tx_skb[loop]);
+static inline int emac_rx_sg_append(struct ocp_enet_private *dev, int slot)
+{
+        if (likely(dev->rx_sg_skb != NULL)) {
+                int len = dev->rx_desc[slot].data_len;
+                int tot_len = dev->rx_sg_skb->len + len;
+
+                if (unlikely(tot_len + 2 > dev->rx_skb_size)) {
+                        ++dev->estats.rx_dropped_mtu;
+                        dev_kfree_skb(dev->rx_sg_skb);
+                        dev->rx_sg_skb = NULL;
+                } else {
+                        cacheable_memcpy(dev->rx_sg_skb->tail,
+                                         dev->rx_skb[slot]->data, len);
+                        skb_put(dev->rx_sg_skb, len);
+                        emac_recycle_rx_skb(dev, slot, len);
+                        return 0;
                 }
-                ep->tx_skb[loop] = NULL;
-                ep->tx_desc[loop].ctrl = 0;
-                ep->tx_desc[loop].data_len = 0;
-                ep->tx_desc[loop].data_ptr = NULL;
-        }
-        ep->tx_desc[loop - 1].ctrl |= MAL_TX_CTRL_WRAP;
-
-        /* Format the receive descriptor ring. */
-        ep->rx_slot = 0;
-        /* Default is MTU=1500 + Ethernet overhead */
-        ep->rx_buffer_size = dev->mtu + ENET_HEADER_SIZE + ENET_FCS_SIZE;
-        emac_rx_fill(dev, 0);
-        if (ep->rx_slot != 0) {
-                printk(KERN_ERR
-                       "%s: Not enough mem for RxChain durning Open?\n",
-                       dev->name);
-                /*We couldn't fill the ring at startup?
-                 *We could clean up and fail to open but right now we will try to
-                 *carry on. It may be a sign of a bad NUM_RX_BUFF value
-                 */
         }
-
-        ep->tx_cnt = 0;
-        ep->tx_slot = 0;
-        ep->ack_slot = 0;
+        emac_recycle_rx_skb(dev, slot, 0);
+        return -1;
 }
 
-static void emac_reset_configure(struct ocp_enet_private *fep)
+/* BHs disabled */
+static int emac_poll_rx(void *param, int budget)
 {
-        emac_t *emacp = fep->emacp;
-        int i;
-
-        mal_disable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
-        mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
+        struct ocp_enet_private *dev = param;
+        int slot = dev->rx_slot, received = 0;
 
-        /*
-         * Check for a link, some PHYs don't provide a clock if
-         * no link is present.  Some EMACs will not come out of
-         * soft reset without a PHY clock present.
-         */
-        if (fep->phy_mii.def->ops->poll_link(&fep->phy_mii)) {
-                /* Reset the EMAC */
-                out_be32(&emacp->em0mr0, EMAC_M0_SRST);
-                udelay(20);
-                for (i = 0; i < 100; i++) {
-                        if ((in_be32(&emacp->em0mr0) & EMAC_M0_SRST) == 0)
-                                break;
-                        udelay(10);
-                }
-
-                if (i >= 100) {
-                        printk(KERN_ERR "%s: Cannot reset EMAC\n",
-                               fep->ndev->name);
-                        return;
-                }
-        }
+        DBG2("%d: poll_rx(%d)" NL, dev->def->index, budget);
 
-        /* Switch IRQs off for now */
-        out_be32(&emacp->em0iser, 0);
+      again:
+        while (budget > 0) {
+                int len;
+                struct sk_buff *skb;
+                u16 ctrl = dev->rx_desc[slot].ctrl;
 
-        /* Configure MAL rx channel */
-        mal_set_rcbs(fep->mal, fep->mal_rx_chan, DESC_BUF_SIZE_REG);
+                if (ctrl & MAL_RX_CTRL_EMPTY)
+                        break;
 
-        /* set the high address */
-        out_be32(&emacp->em0iahr,
-                 (fep->ndev->dev_addr[0] << 8) | fep->ndev->dev_addr[1]);
+                skb = dev->rx_skb[slot];
+                barrier();
+                len = dev->rx_desc[slot].data_len;
 
-        /* set the low address */
-        out_be32(&emacp->em0ialr,
-                 (fep->ndev->dev_addr[2] << 24) | (fep->ndev->dev_addr[3] << 16)
-                 | (fep->ndev->dev_addr[4] << 8) | fep->ndev->dev_addr[5]);
+                if (unlikely(!MAL_IS_SINGLE_RX(ctrl)))
+                        goto sg;
 
-        /* Adjust to link */
-        if (netif_carrier_ok(fep->ndev))
-                emac_adjust_to_link(fep);
+                ctrl &= EMAC_BAD_RX_MASK;
+                if (unlikely(ctrl && ctrl != EMAC_RX_TAH_BAD_CSUM)) {
+                        emac_parse_rx_error(dev, ctrl);
+                        ++dev->estats.rx_dropped_error;
+                        emac_recycle_rx_skb(dev, slot, 0);
+                        len = 0;
+                        goto next;
+                }
 
-        /* enable broadcast/individual address and RX FIFO defaults */
-        out_be32(&emacp->em0rmr, EMAC_RMR_DEFAULT);
+                if (len && len < EMAC_RX_COPY_THRESH) {
+                        struct sk_buff *copy_skb =
+                            alloc_skb(len + EMAC_RX_SKB_HEADROOM + 2, GFP_ATOMIC);
+                        if (unlikely(!copy_skb))
+                                goto oom;
+
+                        skb_reserve(copy_skb, EMAC_RX_SKB_HEADROOM + 2);
+                        cacheable_memcpy(copy_skb->data - 2, skb->data - 2,
+                                         len + 2);
+                        emac_recycle_rx_skb(dev, slot, len);
+                        skb = copy_skb;
+                } else if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC)))
+                        goto oom;
+
+                skb_put(skb, len);
+              push_packet:
+                skb->dev = dev->ndev;
+                skb->protocol = eth_type_trans(skb, dev->ndev);
+                emac_rx_csum(dev, skb, ctrl);
+
+                if (unlikely(netif_receive_skb(skb) == NET_RX_DROP))
+                        ++dev->estats.rx_dropped_stack;
+              next:
+                ++dev->stats.rx_packets;
+              skip:
+                dev->stats.rx_bytes += len;
+                slot = (slot + 1) % NUM_RX_BUFF;
+                --budget;
+                ++received;
+                continue;
+              sg:
+                if (ctrl & MAL_RX_CTRL_FIRST) {
+                        BUG_ON(dev->rx_sg_skb);
+                        if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC))) {
+                                DBG("%d: rx OOM %d" NL, dev->def->index, slot);
+                                ++dev->estats.rx_dropped_oom;
+                                emac_recycle_rx_skb(dev, slot, 0);
+                        } else {
+                                dev->rx_sg_skb = skb;
+                                skb_put(skb, len);
+                        }
+                } else if (!emac_rx_sg_append(dev, slot) &&
+                           (ctrl & MAL_RX_CTRL_LAST)) {
+
+                        skb = dev->rx_sg_skb;
+                        dev->rx_sg_skb = NULL;
+
+                        ctrl &= EMAC_BAD_RX_MASK;
+                        if (unlikely(ctrl && ctrl != EMAC_RX_TAH_BAD_CSUM)) {
+                                emac_parse_rx_error(dev, ctrl);
+                                ++dev->estats.rx_dropped_error;
+                                dev_kfree_skb(skb);
+                                len = 0;
+                        } else
+                                goto push_packet;
+                }
+                goto skip;
+              oom:
+                DBG("%d: rx OOM %d" NL, dev->def->index, slot);
+                /* Drop the packet and recycle skb */
+                ++dev->estats.rx_dropped_oom;
+                emac_recycle_rx_skb(dev, slot, 0);
+                goto next;
+        }
 
-        /* set transmit request threshold register */
-        out_be32(&emacp->em0trtr, EMAC_TRTR_DEFAULT);
+        if (received) {
+                DBG2("%d: rx %d BDs" NL, dev->def->index, received);
+                dev->rx_slot = slot;
+        }
 
-        /* Reconfigure multicast */
-        __emac_set_multicast_list(fep->ndev);
+        if (unlikely(budget && dev->commac.rx_stopped)) {
+                struct ocp_func_emac_data *emacdata = dev->def->additions;
 
-        /* Set receiver/transmitter defaults */
-        out_be32(&emacp->em0rwmr, EMAC_RWMR_DEFAULT);
-        out_be32(&emacp->em0tmr0, EMAC_TMR0_DEFAULT);
-        out_be32(&emacp->em0tmr1, EMAC_TMR1_DEFAULT);
+                barrier();
+                if (!(dev->rx_desc[slot].ctrl & MAL_RX_CTRL_EMPTY)) {
+                        DBG2("%d: rx restart" NL, dev->def->index);
+                        received = 0;
+                        goto again;
+                }
 
-        /* set frame gap */
-        out_be32(&emacp->em0ipgvr, CONFIG_IBM_EMAC_FGAP);
-        
-        /* set VLAN Tag Protocol Identifier */
-        out_be32(&emacp->em0vtpid, 0x8100);
+                if (dev->rx_sg_skb) {
+                        DBG2("%d: dropping partial rx packet" NL,
+                             dev->def->index);
+                        ++dev->estats.rx_dropped_error;
+                        dev_kfree_skb(dev->rx_sg_skb);
+                        dev->rx_sg_skb = NULL;
+                }
 
-        /* Init ring buffers */
-        emac_init_rings(fep->ndev);
+                dev->commac.rx_stopped = 0;
+                mal_enable_rx_channel(dev->mal, emacdata->mal_rx_chan);
+                emac_rx_enable(dev);
+                dev->rx_slot = 0;
+        }
+        return received;
 }
 
-static void emac_kick(struct ocp_enet_private *fep)
+/* BHs disabled */
+static int emac_peek_rx(void *param)
 {
-        emac_t *emacp = fep->emacp;
-        unsigned long emac_ier;
-
-        emac_ier = EMAC_ISR_PP | EMAC_ISR_BP | EMAC_ISR_RP |
-            EMAC_ISR_SE | EMAC_ISR_PTLE | EMAC_ISR_ALE |
-            EMAC_ISR_BFCS | EMAC_ISR_ORE | EMAC_ISR_IRE;
+        struct ocp_enet_private *dev = param;
+        return !(dev->rx_desc[dev->rx_slot].ctrl & MAL_RX_CTRL_EMPTY);
+}
 
-        out_be32(&emacp->em0iser, emac_ier);
+/* BHs disabled */
+static int emac_peek_rx_sg(void *param)
+{
+        struct ocp_enet_private *dev = param;
+        int slot = dev->rx_slot;
+        while (1) {
+                u16 ctrl = dev->rx_desc[slot].ctrl;
+                if (ctrl & MAL_RX_CTRL_EMPTY)
+                        return 0;
+                else if (ctrl & MAL_RX_CTRL_LAST)
+                        return 1;
 
-        /* enable all MAL transmit and receive channels */
-        mal_enable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
-        mal_enable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
+                slot = (slot + 1) % NUM_RX_BUFF;
 
-        /* set transmit and receive enable */
-        out_be32(&emacp->em0mr0, EMAC_M0_TXE | EMAC_M0_RXE);
+                /* I'm just being paranoid here :) */
+                if (unlikely(slot == dev->rx_slot))
+                        return 0;
+        }
 }
 
-static void
-emac_start_link(struct ocp_enet_private *fep, struct ethtool_cmd *ep)
+/* Hard IRQ */
+static void emac_rxde(void *param)
 {
-        u32 advertise;
-        int autoneg;
-        int forced_speed;
-        int forced_duplex;
+        struct ocp_enet_private *dev = param;
+        ++dev->estats.rx_stopped;
+        emac_rx_disable_async(dev);
+}
 
-        /* Default advertise */
-        advertise = ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
-            ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
-            ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full;
-        autoneg = fep->want_autoneg;
-        forced_speed = fep->phy_mii.speed;
-        forced_duplex = fep->phy_mii.duplex;
+/* Hard IRQ */
+static irqreturn_t emac_irq(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ocp_enet_private *dev = dev_instance;
+        struct emac_regs *p = dev->emacp;
+        struct ibm_emac_error_stats *st = &dev->estats;
+
+        u32 isr = in_be32(&p->isr);
+        out_be32(&p->isr, isr);
+
+        DBG("%d: isr = %08x" NL, dev->def->index, isr);
+
+        if (isr & EMAC_ISR_TXPE)
+                ++st->tx_parity;
+        if (isr & EMAC_ISR_RXPE)
+                ++st->rx_parity;
+        if (isr & EMAC_ISR_TXUE)
+                ++st->tx_underrun;
+        if (isr & EMAC_ISR_RXOE)
+                ++st->rx_fifo_overrun;
+        if (isr & EMAC_ISR_OVR)
+                ++st->rx_overrun;
+        if (isr & EMAC_ISR_BP)
+                ++st->rx_bad_packet;
+        if (isr & EMAC_ISR_RP)
+                ++st->rx_runt_packet;
+        if (isr & EMAC_ISR_SE)
+                ++st->rx_short_event;
+        if (isr & EMAC_ISR_ALE)
+                ++st->rx_alignment_error;
+        if (isr & EMAC_ISR_BFCS)
+                ++st->rx_bad_fcs;
+        if (isr & EMAC_ISR_PTLE)
+                ++st->rx_packet_too_long;
+        if (isr & EMAC_ISR_ORE)
+                ++st->rx_out_of_range;
+        if (isr & EMAC_ISR_IRE)
+                ++st->rx_in_range;
+        if (isr & EMAC_ISR_SQE)
+                ++st->tx_sqe;
+        if (isr & EMAC_ISR_TE)
+                ++st->tx_errors;
 
-        /* Setup link parameters */
-        if (ep) {
-                if (ep->autoneg == AUTONEG_ENABLE) {
-                        advertise = ep->advertising;
-                        autoneg = 1;
-                } else {
-                        autoneg = 0;
-                        forced_speed = ep->speed;
-                        forced_duplex = ep->duplex;
-                }
-        }
+        return IRQ_HANDLED;
+}
 
-        /* Configure PHY & start aneg */
-        fep->want_autoneg = autoneg;
-        if (autoneg) {
-                LINK_DEBUG(("%s: start link aneg, advertise: 0x%x\n",
-                            fep->ndev->name, advertise));
-                fep->phy_mii.def->ops->setup_aneg(&fep->phy_mii, advertise);
-        } else {
-                LINK_DEBUG(("%s: start link forced, speed: %d, duplex: %d\n",
-                            fep->ndev->name, forced_speed, forced_duplex));
-                fep->phy_mii.def->ops->setup_forced(&fep->phy_mii, forced_speed,
-                                                    forced_duplex);
-        }
-        fep->timer_ticks = 0;
-        mod_timer(&fep->link_timer, jiffies + HZ);
+static struct net_device_stats *emac_stats(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct ibm_emac_stats *st = &dev->stats;
+        struct ibm_emac_error_stats *est = &dev->estats;
+        struct net_device_stats *nst = &dev->nstats;
+
+        DBG2("%d: stats" NL, dev->def->index);
+
+        /* Compute "legacy" statistics */
+        local_irq_disable();
+        nst->rx_packets = (unsigned long)st->rx_packets;
+        nst->rx_bytes = (unsigned long)st->rx_bytes;
+        nst->tx_packets = (unsigned long)st->tx_packets;
+        nst->tx_bytes = (unsigned long)st->tx_bytes;
+        nst->rx_dropped = (unsigned long)(est->rx_dropped_oom +
+                                          est->rx_dropped_error +
+                                          est->rx_dropped_resize +
+                                          est->rx_dropped_mtu);
+        nst->tx_dropped = (unsigned long)est->tx_dropped;
+
+        nst->rx_errors = (unsigned long)est->rx_bd_errors;
+        nst->rx_fifo_errors = (unsigned long)(est->rx_bd_overrun +
+                                              est->rx_fifo_overrun +
+                                              est->rx_overrun);
+        nst->rx_frame_errors = (unsigned long)(est->rx_bd_alignment_error +
+                                               est->rx_alignment_error);
+        nst->rx_crc_errors = (unsigned long)(est->rx_bd_bad_fcs +
+                                             est->rx_bad_fcs);
+        nst->rx_length_errors = (unsigned long)(est->rx_bd_runt_packet +
+                                                est->rx_bd_short_event +
+                                                est->rx_bd_packet_too_long +
+                                                est->rx_bd_out_of_range +
+                                                est->rx_bd_in_range +
+                                                est->rx_runt_packet +
+                                                est->rx_short_event +
+                                                est->rx_packet_too_long +
+                                                est->rx_out_of_range +
+                                                est->rx_in_range);
+
+        nst->tx_errors = (unsigned long)(est->tx_bd_errors + est->tx_errors);
+        nst->tx_fifo_errors = (unsigned long)(est->tx_bd_underrun +
+                                              est->tx_underrun);
+        nst->tx_carrier_errors = (unsigned long)est->tx_bd_carrier_loss;
+        nst->collisions = (unsigned long)(est->tx_bd_excessive_deferral +
+                                          est->tx_bd_excessive_collisions +
+                                          est->tx_bd_late_collision +
+                                          est->tx_bd_multple_collisions);
+        local_irq_enable();
+        return nst;
 }
 
-static void emac_link_timer(unsigned long data)
+static void emac_remove(struct ocp_device *ocpdev)
 {
-        struct ocp_enet_private *fep = (struct ocp_enet_private *)data;
-        int link;
+        struct ocp_enet_private *dev = ocp_get_drvdata(ocpdev);
 
-        if (fep->going_away)
-                return;
+        DBG("%d: remove" NL, dev->def->index);
 
-        spin_lock_irq(&fep->lock);
+        ocp_set_drvdata(ocpdev, 0);
+        unregister_netdev(dev->ndev);
 
-        link = fep->phy_mii.def->ops->poll_link(&fep->phy_mii);
-        LINK_DEBUG(("%s: poll_link: %d\n", fep->ndev->name, link));
+        tah_fini(dev->tah_dev);
+        rgmii_fini(dev->rgmii_dev, dev->rgmii_input);
+        zmii_fini(dev->zmii_dev, dev->zmii_input);
 
-        if (link == netif_carrier_ok(fep->ndev)) {
-                if (!link && fep->want_autoneg && (++fep->timer_ticks) > 10)
-                        emac_start_link(fep, NULL);
-                goto out;
-        }
-        printk(KERN_INFO "%s: Link is %s\n", fep->ndev->name,
-               link ? "Up" : "Down");
-        if (link) {
-                netif_carrier_on(fep->ndev);
-                /* Chip needs a full reset on config change. That sucks, so I
-                 * should ultimately move that to some tasklet to limit
-                 * latency peaks caused by this code
-                 */
-                emac_reset_configure(fep);
-                if (fep->opened)
-                        emac_kick(fep);
-        } else {
-                fep->timer_ticks = 0;
-                netif_carrier_off(fep->ndev);
-        }
-      out:
-        mod_timer(&fep->link_timer, jiffies + HZ);
-        spin_unlock_irq(&fep->lock);
+        emac_dbg_register(dev->def->index, 0);
+
+        mal_unregister_commac(dev->mal, &dev->commac);
+        iounmap((void *)dev->emacp);
+        kfree(dev->ndev);
 }
 
-static void emac_set_multicast_list(struct net_device *dev)
-{
-        struct ocp_enet_private *fep = dev->priv;
+static struct mal_commac_ops emac_commac_ops = {
+        .poll_tx = &emac_poll_tx,
+        .poll_rx = &emac_poll_rx,
+        .peek_rx = &emac_peek_rx,
+        .rxde = &emac_rxde,
+};
 
-        spin_lock_irq(&fep->lock);
-        __emac_set_multicast_list(dev);
-        spin_unlock_irq(&fep->lock);
-}
+static struct mal_commac_ops emac_commac_sg_ops = {
+        .poll_tx = &emac_poll_tx,
+        .poll_rx = &emac_poll_rx,
+        .peek_rx = &emac_peek_rx_sg,
+        .rxde = &emac_rxde,
+};
 
-static int emac_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
+/* Ethtool support */
+static int emac_ethtool_get_settings(struct net_device *ndev,
+                                     struct ethtool_cmd *cmd)
 {
-        struct ocp_enet_private *fep = ndev->priv;
+        struct ocp_enet_private *dev = ndev->priv;
 
-        cmd->supported = fep->phy_mii.def->features;
+        cmd->supported = dev->phy.features;
         cmd->port = PORT_MII;
-        cmd->transceiver = XCVR_EXTERNAL;
-        cmd->phy_address = fep->mii_phy_addr;
-        spin_lock_irq(&fep->lock);
-        cmd->autoneg = fep->want_autoneg;
-        cmd->speed = fep->phy_mii.speed;
-        cmd->duplex = fep->phy_mii.duplex;
-        spin_unlock_irq(&fep->lock);
+        cmd->phy_address = dev->phy.address;
+        cmd->transceiver =
+            dev->phy.address >= 0 ? XCVR_EXTERNAL : XCVR_INTERNAL;
+
+        local_bh_disable();
+        cmd->advertising = dev->phy.advertising;
+        cmd->autoneg = dev->phy.autoneg;
+        cmd->speed = dev->phy.speed;
+        cmd->duplex = dev->phy.duplex;
+        local_bh_enable();
+
         return 0;
 }
 
-static int emac_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
+static int emac_ethtool_set_settings(struct net_device *ndev,
+                                     struct ethtool_cmd *cmd)
 {
-        struct ocp_enet_private *fep = ndev->priv;
-        unsigned long features = fep->phy_mii.def->features;
+        struct ocp_enet_private *dev = ndev->priv;
+        u32 f = dev->phy.features;
 
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
+        DBG("%d: set_settings(%d, %d, %d, 0x%08x)" NL, dev->def->index,
+            cmd->autoneg, cmd->speed, cmd->duplex, cmd->advertising);
 
+        /* Basic sanity checks */
+        if (dev->phy.address < 0)
+                return -EOPNOTSUPP;
         if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
                 return -EINVAL;
         if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
                 return -EINVAL;
         if (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL)
                 return -EINVAL;
-        if (cmd->autoneg == AUTONEG_DISABLE)
+
+        if (cmd->autoneg == AUTONEG_DISABLE) {
                 switch (cmd->speed) {
                 case SPEED_10:
-                        if (cmd->duplex == DUPLEX_HALF &&
-                            (features & SUPPORTED_10baseT_Half) == 0)
+                        if (cmd->duplex == DUPLEX_HALF
+                            && !(f & SUPPORTED_10baseT_Half))
                                 return -EINVAL;
-                        if (cmd->duplex == DUPLEX_FULL &&
-                            (features & SUPPORTED_10baseT_Full) == 0)
+                        if (cmd->duplex == DUPLEX_FULL
+                            && !(f & SUPPORTED_10baseT_Full))
                                 return -EINVAL;
                         break;
                 case SPEED_100:
-                        if (cmd->duplex == DUPLEX_HALF &&
-                            (features & SUPPORTED_100baseT_Half) == 0)
+                        if (cmd->duplex == DUPLEX_HALF
+                            && !(f & SUPPORTED_100baseT_Half))
                                 return -EINVAL;
-                        if (cmd->duplex == DUPLEX_FULL &&
-                            (features & SUPPORTED_100baseT_Full) == 0)
+                        if (cmd->duplex == DUPLEX_FULL
+                            && !(f & SUPPORTED_100baseT_Full))
                                 return -EINVAL;
                         break;
                 case SPEED_1000:
-                        if (cmd->duplex == DUPLEX_HALF &&
-                            (features & SUPPORTED_1000baseT_Half) == 0)
+                        if (cmd->duplex == DUPLEX_HALF
+                            && !(f & SUPPORTED_1000baseT_Half))
                                 return -EINVAL;
-                        if (cmd->duplex == DUPLEX_FULL &&
-                            (features & SUPPORTED_1000baseT_Full) == 0)
+                        if (cmd->duplex == DUPLEX_FULL
+                            && !(f & SUPPORTED_1000baseT_Full))
                                 return -EINVAL;
                         break;
                 default:
                         return -EINVAL;
-        } else if ((features & SUPPORTED_Autoneg) == 0)
-                return -EINVAL;
-        spin_lock_irq(&fep->lock);
-        emac_start_link(fep, cmd);
-        spin_unlock_irq(&fep->lock);
+                }
+
+                local_bh_disable();
+                dev->phy.def->ops->setup_forced(&dev->phy, cmd->speed,
+                                                cmd->duplex);
+
+        } else {
+                if (!(f & SUPPORTED_Autoneg))
+                        return -EINVAL;
+
+                local_bh_disable();
+                dev->phy.def->ops->setup_aneg(&dev->phy,
+                                              (cmd->advertising & f) |
+                                              (dev->phy.advertising &
+                                               (ADVERTISED_Pause |
+                                                ADVERTISED_Asym_Pause)));
+        }
+        emac_force_link_update(dev);
+        local_bh_enable();
+
         return 0;
 }
 
-static void
-emac_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
+static void emac_ethtool_get_ringparam(struct net_device *ndev,
+                                       struct ethtool_ringparam *rp)
 {
-        struct ocp_enet_private *fep = ndev->priv;
-
-        strcpy(info->driver, DRV_NAME);
-        strcpy(info->version, DRV_VERSION);
-        info->fw_version[0] = '\0';
-        sprintf(info->bus_info, "IBM EMAC %d", fep->ocpdev->def->index);
-        info->regdump_len = 0;
+        rp->rx_max_pending = rp->rx_pending = NUM_RX_BUFF;
+        rp->tx_max_pending = rp->tx_pending = NUM_TX_BUFF;
 }
 
-static int emac_nway_reset(struct net_device *ndev)
+static void emac_ethtool_get_pauseparam(struct net_device *ndev,
+                                        struct ethtool_pauseparam *pp)
 {
-        struct ocp_enet_private *fep = ndev->priv;
+        struct ocp_enet_private *dev = ndev->priv;
+
+        local_bh_disable();
+        if ((dev->phy.features & SUPPORTED_Autoneg) &&
+            (dev->phy.advertising & (ADVERTISED_Pause | ADVERTISED_Asym_Pause)))
+                pp->autoneg = 1;
+
+        if (dev->phy.duplex == DUPLEX_FULL) {
+                if (dev->phy.pause)
+                        pp->rx_pause = pp->tx_pause = 1;
+                else if (dev->phy.asym_pause)
+                        pp->tx_pause = 1;
+        }
+        local_bh_enable();
+}
 
-        if (!fep->want_autoneg)
-                return -EINVAL;
-        spin_lock_irq(&fep->lock);
-        emac_start_link(fep, NULL);
-        spin_unlock_irq(&fep->lock);
-        return 0;
+static u32 emac_ethtool_get_rx_csum(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        return dev->tah_dev != 0;
 }
 
-static u32 emac_get_link(struct net_device *ndev)
+static int emac_get_regs_len(struct ocp_enet_private *dev)
 {
-        return netif_carrier_ok(ndev);
+        return sizeof(struct emac_ethtool_regs_subhdr) + EMAC_ETHTOOL_REGS_SIZE;
 }
 
-static struct ethtool_ops emac_ethtool_ops = {
-        .get_settings = emac_get_settings,
-        .set_settings = emac_set_settings,
-        .get_drvinfo = emac_get_drvinfo,
-        .nway_reset = emac_nway_reset,
-        .get_link = emac_get_link
-};
+static int emac_ethtool_get_regs_len(struct net_device *ndev)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        return sizeof(struct emac_ethtool_regs_hdr) +
+            emac_get_regs_len(dev) + mal_get_regs_len(dev->mal) +
+            zmii_get_regs_len(dev->zmii_dev) +
+            rgmii_get_regs_len(dev->rgmii_dev) +
+            tah_get_regs_len(dev->tah_dev);
+}
 
-static int emac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+static void *emac_dump_regs(struct ocp_enet_private *dev, void *buf)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        uint16_t *data = (uint16_t *) & rq->ifr_ifru;
+        struct emac_ethtool_regs_subhdr *hdr = buf;
 
-        switch (cmd) {
-        case SIOCGMIIPHY:
-                data[0] = fep->mii_phy_addr;
-                /* Fall through */
-        case SIOCGMIIREG:
-                data[3] = emac_phy_read(dev, fep->mii_phy_addr, data[1]);
-                return 0;
-        case SIOCSMIIREG:
-                if (!capable(CAP_NET_ADMIN))
-                        return -EPERM;
+        hdr->version = EMAC_ETHTOOL_REGS_VER;
+        hdr->index = dev->def->index;
+        memcpy_fromio(hdr + 1, dev->emacp, EMAC_ETHTOOL_REGS_SIZE);
+        return ((void *)(hdr + 1) + EMAC_ETHTOOL_REGS_SIZE);
+}
 
-                emac_phy_write(dev, fep->mii_phy_addr, data[1], data[2]);
-                return 0;
-        default:
-                return -EOPNOTSUPP;
+static void emac_ethtool_get_regs(struct net_device *ndev,
+                                  struct ethtool_regs *regs, void *buf)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        struct emac_ethtool_regs_hdr *hdr = buf;
+
+        hdr->components = 0;
+        buf = hdr + 1;
+
+        local_irq_disable();
+        buf = mal_dump_regs(dev->mal, buf);
+        buf = emac_dump_regs(dev, buf);
+        if (dev->zmii_dev) {
+                hdr->components |= EMAC_ETHTOOL_REGS_ZMII;
+                buf = zmii_dump_regs(dev->zmii_dev, buf);
         }
+        if (dev->rgmii_dev) {
+                hdr->components |= EMAC_ETHTOOL_REGS_RGMII;
+                buf = rgmii_dump_regs(dev->rgmii_dev, buf);
+        }
+        if (dev->tah_dev) {
+                hdr->components |= EMAC_ETHTOOL_REGS_TAH;
+                buf = tah_dump_regs(dev->tah_dev, buf);
+        }
+        local_irq_enable();
 }
 
-static int emac_open(struct net_device *dev)
+static int emac_ethtool_nway_reset(struct net_device *ndev)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        int rc;
+        struct ocp_enet_private *dev = ndev->priv;
+        int res = 0;
 
-        spin_lock_irq(&fep->lock);
+        DBG("%d: nway_reset" NL, dev->def->index);
 
-        fep->opened = 1;
-        netif_carrier_off(dev);
+        if (dev->phy.address < 0)
+                return -EOPNOTSUPP;
 
-        /* Reset & configure the chip */
-        emac_reset_configure(fep);
+        local_bh_disable();
+        if (!dev->phy.autoneg) {
+                res = -EINVAL;
+                goto out;
+        }
 
-        spin_unlock_irq(&fep->lock);
+        dev->phy.def->ops->setup_aneg(&dev->phy, dev->phy.advertising);
+        emac_force_link_update(dev);
 
-        /* Request our interrupt lines */
-        rc = request_irq(dev->irq, emac_mac_irq, 0, "IBM EMAC MAC", dev);
-        if (rc != 0) {
-                printk("dev->irq %d failed\n", dev->irq);
-                goto bail;
-        }
-        /* Kick the chip rx & tx channels into life */
-        spin_lock_irq(&fep->lock);
-        emac_kick(fep);
-        spin_unlock_irq(&fep->lock);
+      out:
+        local_bh_enable();
+        return res;
+}
 
-        netif_start_queue(dev);
-      bail:
-        return rc;
+static int emac_ethtool_get_stats_count(struct net_device *ndev)
+{
+        return EMAC_ETHTOOL_STATS_COUNT;
 }
 
-static int emac_close(struct net_device *dev)
+static void emac_ethtool_get_strings(struct net_device *ndev, u32 stringset,
+                                     u8 * buf)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        emac_t *emacp = fep->emacp;
+        if (stringset == ETH_SS_STATS)
+                memcpy(buf, &emac_stats_keys, sizeof(emac_stats_keys));
+}
 
-        /* XXX Stop IRQ emitting here */
-        spin_lock_irq(&fep->lock);
-        fep->opened = 0;
-        mal_disable_tx_channels(fep->mal, fep->commac.tx_chan_mask);
-        mal_disable_rx_channels(fep->mal, fep->commac.rx_chan_mask);
-        netif_carrier_off(dev);
-        netif_stop_queue(dev);
+static void emac_ethtool_get_ethtool_stats(struct net_device *ndev,
+                                           struct ethtool_stats *estats,
+                                           u64 * tmp_stats)
+{
+        struct ocp_enet_private *dev = ndev->priv;
+        local_irq_disable();
+        memcpy(tmp_stats, &dev->stats, sizeof(dev->stats));
+        tmp_stats += sizeof(dev->stats) / sizeof(u64);
+        memcpy(tmp_stats, &dev->estats, sizeof(dev->estats));
+        local_irq_enable();
+}
 
-        /*
-         * Check for a link, some PHYs don't provide a clock if
-         * no link is present.  Some EMACs will not come out of
-         * soft reset without a PHY clock present.
-         */
-        if (fep->phy_mii.def->ops->poll_link(&fep->phy_mii)) {
-                out_be32(&emacp->em0mr0, EMAC_M0_SRST);
-                udelay(10);
+static void emac_ethtool_get_drvinfo(struct net_device *ndev,
+                                     struct ethtool_drvinfo *info)
+{
+        struct ocp_enet_private *dev = ndev->priv;
 
-                if (emacp->em0mr0 & EMAC_M0_SRST) {
-                        /*not sure what to do here hopefully it clears before another open */
-                        printk(KERN_ERR
-                               "%s: Phy SoftReset didn't clear, no link?\n",
-                               dev->name);
-                }
-        }
+        strcpy(info->driver, "ibm_emac");
+        strcpy(info->version, DRV_VERSION);
+        info->fw_version[0] = '\0';
+        sprintf(info->bus_info, "PPC 4xx EMAC %d", dev->def->index);
+        info->n_stats = emac_ethtool_get_stats_count(ndev);
+        info->regdump_len = emac_ethtool_get_regs_len(ndev);
+}
 
-        /* Free the irq's */
-        free_irq(dev->irq, dev);
+static struct ethtool_ops emac_ethtool_ops = {
+        .get_settings = emac_ethtool_get_settings,
+        .set_settings = emac_ethtool_set_settings,
+        .get_drvinfo = emac_ethtool_get_drvinfo,
 
-        spin_unlock_irq(&fep->lock);
+        .get_regs_len = emac_ethtool_get_regs_len,
+        .get_regs = emac_ethtool_get_regs,
 
-        return 0;
-}
+        .nway_reset = emac_ethtool_nway_reset,
 
-static void emac_remove(struct ocp_device *ocpdev)
-{
-        struct net_device *dev = ocp_get_drvdata(ocpdev);
-        struct ocp_enet_private *ep = dev->priv;
-
-        /* FIXME: locking, races, ... */
-        ep->going_away = 1;
-        ocp_set_drvdata(ocpdev, NULL);
-        if (ep->rgmii_dev)
-                emac_close_rgmii(ep->rgmii_dev);
-        if (ep->zmii_dev)
-                emac_close_zmii(ep->zmii_dev);
-
-        unregister_netdev(dev);
-        del_timer_sync(&ep->link_timer);
-        mal_unregister_commac(ep->mal, &ep->commac);
-        iounmap((void *)ep->emacp);
-        kfree(dev);
-}
-
-struct mal_commac_ops emac_commac_ops = {
-        .txeob = &emac_txeob_dev,
-        .txde = &emac_txde_dev,
-        .rxeob = &emac_rxeob_dev,
-        .rxde = &emac_rxde_dev,
+        .get_ringparam = emac_ethtool_get_ringparam,
+        .get_pauseparam = emac_ethtool_get_pauseparam,
+
+        .get_rx_csum = emac_ethtool_get_rx_csum,
+
+        .get_strings = emac_ethtool_get_strings,
+        .get_stats_count = emac_ethtool_get_stats_count,
+        .get_ethtool_stats = emac_ethtool_get_ethtool_stats,
+
+        .get_link = ethtool_op_get_link,
+        .get_tx_csum = ethtool_op_get_tx_csum,
+        .get_sg = ethtool_op_get_sg,
 };
 
-#ifdef CONFIG_NET_POLL_CONTROLLER
-static void emac_netpoll(struct net_device *ndev)
+static int emac_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
 {
-        emac_rxeob_dev((void *)ndev, 0);
-        emac_txeob_dev((void *)ndev, 0);
+        struct ocp_enet_private *dev = ndev->priv;
+        uint16_t *data = (uint16_t *) & rq->ifr_ifru;
+
+        DBG("%d: ioctl %08x" NL, dev->def->index, cmd);
+
+        if (dev->phy.address < 0)
+                return -EOPNOTSUPP;
+
+        switch (cmd) {
+        case SIOCGMIIPHY:
+        case SIOCDEVPRIVATE:
+                data[0] = dev->phy.address;
+                /* Fall through */
+        case SIOCGMIIREG:
+        case SIOCDEVPRIVATE + 1:
+                data[3] = emac_mdio_read(ndev, dev->phy.address, data[1]);
+                return 0;
+
+        case SIOCSMIIREG:
+        case SIOCDEVPRIVATE + 2:
+                if (!capable(CAP_NET_ADMIN))
+                        return -EPERM;
+                emac_mdio_write(ndev, dev->phy.address, data[1], data[2]);
+                return 0;
+        default:
+                return -EOPNOTSUPP;
+        }
 }
-#endif
 
-static int emac_init_device(struct ocp_device *ocpdev, struct ibm_ocp_mal *mal)
+static int __init emac_probe(struct ocp_device *ocpdev)
 {
-        int deferred_init = 0;
-        int rc = 0, i;
+        struct ocp_func_emac_data *emacdata = ocpdev->def->additions;
         struct net_device *ndev;
-        struct ocp_enet_private *ep;
-        struct ocp_func_emac_data *emacdata;
-        int commac_reg = 0;
-        u32 phy_map;
+        struct ocp_device *maldev;
+        struct ocp_enet_private *dev;
+        int err, i;
+
+        DBG("%d: probe" NL, ocpdev->def->index);
 
-        emacdata = (struct ocp_func_emac_data *)ocpdev->def->additions;
         if (!emacdata) {
                 printk(KERN_ERR "emac%d: Missing additional data!\n",
                        ocpdev->def->index);
@@ -1738,304 +1936,312 @@ static int emac_init_device(struct ocp_device *ocpdev, struct ibm_ocp_mal *mal)
 
         /* Allocate our net_device structure */
         ndev = alloc_etherdev(sizeof(struct ocp_enet_private));
-        if (ndev == NULL) {
-                printk(KERN_ERR
-                       "emac%d: Could not allocate ethernet device.\n",
+        if (!ndev) {
+                printk(KERN_ERR "emac%d: could not allocate ethernet device!\n",
                        ocpdev->def->index);
                 return -ENOMEM;
         }
-        ep = ndev->priv;
-        ep->ndev = ndev;
-        ep->ocpdev = ocpdev;
-        ndev->irq = ocpdev->def->irq;
-        ep->wol_irq = emacdata->wol_irq;
-        if (emacdata->mdio_idx >= 0) {
-                if (emacdata->mdio_idx == ocpdev->def->index) {
-                        /* Set the common MDIO net_device */
-                        mdio_ndev = ndev;
-                        deferred_init = 1;
-                }
-                ep->mdio_dev = mdio_ndev;
-        } else {
-                ep->mdio_dev = ndev;
-        }
+        dev = ndev->priv;
+        dev->ndev = ndev;
+        dev->ldev = &ocpdev->dev;
+        dev->def = ocpdev->def;
+        SET_MODULE_OWNER(ndev);
 
-        ocp_set_drvdata(ocpdev, ndev);
-
-        spin_lock_init(&ep->lock);
-
-        /* Fill out MAL informations and register commac */
-        ep->mal = mal;
-        ep->mal_tx_chan = emacdata->mal_tx_chan;
-        ep->mal_rx_chan = emacdata->mal_rx_chan;
-        ep->commac.ops = &emac_commac_ops;
-        ep->commac.dev = ndev;
-        ep->commac.tx_chan_mask = MAL_CHAN_MASK(ep->mal_tx_chan);
-        ep->commac.rx_chan_mask = MAL_CHAN_MASK(ep->mal_rx_chan);
-        rc = mal_register_commac(ep->mal, &ep->commac);
-        if (rc != 0)
-                goto bail;
-        commac_reg = 1;
-
-        /* Map our MMIOs */
-        ep->emacp = (emac_t *) ioremap(ocpdev->def->paddr, sizeof(emac_t));
-
-        /* Check if we need to attach to a ZMII */
-        if (emacdata->zmii_idx >= 0) {
-                ep->zmii_input = emacdata->zmii_mux;
-                ep->zmii_dev =
-                    ocp_find_device(OCP_ANY_ID, OCP_FUNC_ZMII,
-                                    emacdata->zmii_idx);
-                if (ep->zmii_dev == NULL)
-                        printk(KERN_WARNING
-                               "emac%d: ZMII %d requested but not found !\n",
-                               ocpdev->def->index, emacdata->zmii_idx);
-                else if ((rc =
-                          emac_init_zmii(ep->zmii_dev, ep->zmii_input,
-                                         emacdata->phy_mode)) != 0)
-                        goto bail;
+        /* Find MAL device we are connected to */
+        maldev =
+            ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_MAL, emacdata->mal_idx);
+        if (!maldev) {
+                printk(KERN_ERR "emac%d: unknown mal%d device!\n",
+                       dev->def->index, emacdata->mal_idx);
+                err = -ENODEV;
+                goto out;
+        }
+        dev->mal = ocp_get_drvdata(maldev);
+        if (!dev->mal) {
+                printk(KERN_ERR "emac%d: mal%d hasn't been initialized yet!\n",
+                       dev->def->index, emacdata->mal_idx);
+                err = -ENODEV;
+                goto out;
         }
 
-        /* Check if we need to attach to a RGMII */
-        if (emacdata->rgmii_idx >= 0) {
-                ep->rgmii_input = emacdata->rgmii_mux;
-                ep->rgmii_dev =
-                    ocp_find_device(OCP_ANY_ID, OCP_FUNC_RGMII,
-                                    emacdata->rgmii_idx);
-                if (ep->rgmii_dev == NULL)
-                        printk(KERN_WARNING
-                               "emac%d: RGMII %d requested but not found !\n",
-                               ocpdev->def->index, emacdata->rgmii_idx);
-                else if ((rc =
-                          emac_init_rgmii(ep->rgmii_dev, ep->rgmii_input,
-                                          emacdata->phy_mode)) != 0)
-                        goto bail;
+        /* Register with MAL */
+        dev->commac.ops = &emac_commac_ops;
+        dev->commac.dev = dev;
+        dev->commac.tx_chan_mask = MAL_CHAN_MASK(emacdata->mal_tx_chan);
+        dev->commac.rx_chan_mask = MAL_CHAN_MASK(emacdata->mal_rx_chan);
+        err = mal_register_commac(dev->mal, &dev->commac);
+        if (err) {
+                printk(KERN_ERR "emac%d: failed to register with mal%d!\n",
+                       dev->def->index, emacdata->mal_idx);
+                goto out;
+        }
+        dev->rx_skb_size = emac_rx_skb_size(ndev->mtu);
+        dev->rx_sync_size = emac_rx_sync_size(ndev->mtu);
+
+        /* Get pointers to BD rings */
+        dev->tx_desc =
+            dev->mal->bd_virt + mal_tx_bd_offset(dev->mal,
+                                                 emacdata->mal_tx_chan);
+        dev->rx_desc =
+            dev->mal->bd_virt + mal_rx_bd_offset(dev->mal,
+                                                 emacdata->mal_rx_chan);
+
+        DBG("%d: tx_desc %p" NL, ocpdev->def->index, dev->tx_desc);
+        DBG("%d: rx_desc %p" NL, ocpdev->def->index, dev->rx_desc);
+
+        /* Clean rings */
+        memset(dev->tx_desc, 0, NUM_TX_BUFF * sizeof(struct mal_descriptor));
+        memset(dev->rx_desc, 0, NUM_RX_BUFF * sizeof(struct mal_descriptor));
+
+        /* If we depend on another EMAC for MDIO, check whether it was probed already */
+        if (emacdata->mdio_idx >= 0 && emacdata->mdio_idx != ocpdev->def->index) {
+                struct ocp_device *mdiodev =
+                    ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_EMAC,
+                                    emacdata->mdio_idx);
+                if (!mdiodev) {
+                        printk(KERN_ERR "emac%d: unknown emac%d device!\n",
+                               dev->def->index, emacdata->mdio_idx);
+                        err = -ENODEV;
+                        goto out2;
+                }
+                dev->mdio_dev = ocp_get_drvdata(mdiodev);
+                if (!dev->mdio_dev) {
+                        printk(KERN_ERR
+                               "emac%d: emac%d hasn't been initialized yet!\n",
+                               dev->def->index, emacdata->mdio_idx);
+                        err = -ENODEV;
+                        goto out2;
+                }
         }
 
-        /* Check if we need to attach to a TAH */
-        if (emacdata->tah_idx >= 0) {
-                ep->tah_dev =
-                    ocp_find_device(OCP_ANY_ID, OCP_FUNC_TAH,
-                                    emacdata->tah_idx);
-                if (ep->tah_dev == NULL)
-                        printk(KERN_WARNING
-                               "emac%d: TAH %d requested but not found !\n",
-                               ocpdev->def->index, emacdata->tah_idx);
-                else if ((rc = emac_init_tah(ep)) != 0)
-                        goto bail;
+        /* Attach to ZMII, if needed */
+        if ((err = zmii_attach(dev)) != 0)
+                goto out2;
+
+        /* Attach to RGMII, if needed */
+        if ((err = rgmii_attach(dev)) != 0)
+                goto out3;
+
+        /* Attach to TAH, if needed */
+        if ((err = tah_attach(dev)) != 0)
+                goto out4;
+
+        /* Map EMAC regs */
+        dev->emacp =
+            (struct emac_regs *)ioremap(dev->def->paddr,
+                                        sizeof(struct emac_regs));
+        if (!dev->emacp) {
+                printk(KERN_ERR "emac%d: could not ioremap device registers!\n",
+                       dev->def->index);
+                err = -ENOMEM;
+                goto out5;
         }
 
-        if (deferred_init) {
-                if (!list_empty(&emac_init_list)) {
-                        struct list_head *entry;
-                        struct emac_def_dev *ddev;
+        /* Fill in MAC address */
+        for (i = 0; i < 6; ++i)
+                ndev->dev_addr[i] = emacdata->mac_addr[i];
 
-                        list_for_each(entry, &emac_init_list) {
-                                ddev =
-                                    list_entry(entry, struct emac_def_dev,
-                                               link);
-                                emac_init_device(ddev->ocpdev, ddev->mal);
-                        }
+        /* Set some link defaults before we can find out real parameters */
+        dev->phy.speed = SPEED_100;
+        dev->phy.duplex = DUPLEX_FULL;
+        dev->phy.autoneg = AUTONEG_DISABLE;
+        dev->phy.pause = dev->phy.asym_pause = 0;
+        init_timer(&dev->link_timer);
+        dev->link_timer.function = emac_link_timer;
+        dev->link_timer.data = (unsigned long)dev;
+
+        /* Find PHY if any */
+        dev->phy.dev = ndev;
+        dev->phy.mode = emacdata->phy_mode;
+        if (emacdata->phy_map != 0xffffffff) {
+                u32 phy_map = emacdata->phy_map | busy_phy_map;
+                u32 adv;
+
+                DBG("%d: PHY maps %08x %08x" NL, dev->def->index,
+                    emacdata->phy_map, busy_phy_map);
+
+                EMAC_RX_CLK_TX(dev->def->index);
+
+                dev->phy.mdio_read = emac_mdio_read;
+                dev->phy.mdio_write = emac_mdio_write;
+
+                /* Configure EMAC with defaults so we can at least use MDIO
+                 * This is needed mostly for 440GX
+                 */
+                if (emac_phy_gpcs(dev->phy.mode)) {
+                        /* XXX
+                         * Make GPCS PHY address equal to EMAC index.
+                         * We probably should take into account busy_phy_map
+                         * and/or phy_map here.
+                         */
+                        dev->phy.address = dev->def->index;
                 }
-        }
+                
+                emac_configure(dev);
 
-        /* Init link monitoring timer */
-        init_timer(&ep->link_timer);
-        ep->link_timer.function = emac_link_timer;
-        ep->link_timer.data = (unsigned long)ep;
-        ep->timer_ticks = 0;
-
-        /* Fill up the mii_phy structure */
-        ep->phy_mii.dev = ndev;
-        ep->phy_mii.mdio_read = emac_phy_read;
-        ep->phy_mii.mdio_write = emac_phy_write;
-        ep->phy_mii.mode = emacdata->phy_mode;
-
-        /* Find PHY */
-        phy_map = emacdata->phy_map | busy_phy_map;
-        for (i = 0; i <= 0x1f; i++, phy_map >>= 1) {
-                if ((phy_map & 0x1) == 0) {
-                        int val = emac_phy_read(ndev, i, MII_BMCR);
-                        if (val != 0xffff && val != -1)
-                                break;
+                for (i = 0; i < 0x20; phy_map >>= 1, ++i)
+                        if (!(phy_map & 1)) {
+                                int r;
+                                busy_phy_map |= 1 << i;
+
+                                /* Quick check if there is a PHY at the address */
+                                r = emac_mdio_read(dev->ndev, i, MII_BMCR);
+                                if (r == 0xffff || r < 0)
+                                        continue;
+                                if (!mii_phy_probe(&dev->phy, i))
+                                        break;
+                        }
+                if (i == 0x20) {
+                        printk(KERN_WARNING "emac%d: can't find PHY!\n",
+                               dev->def->index);
+                        goto out6;
                 }
-        }
-        if (i == 0x20) {
-                printk(KERN_WARNING "emac%d: Can't find PHY.\n",
-                       ocpdev->def->index);
-                rc = -ENODEV;
-                goto bail;
-        }
-        busy_phy_map |= 1 << i;
-        ep->mii_phy_addr = i;
-        rc = mii_phy_probe(&ep->phy_mii, i);
-        if (rc) {
-                printk(KERN_WARNING "emac%d: Failed to probe PHY type.\n",
-                       ocpdev->def->index);
-                rc = -ENODEV;
-                goto bail;
-        }
-        
-        /* Disable any PHY features not supported by the platform */
-        ep->phy_mii.def->features &= ~emacdata->phy_feat_exc;
 
-        /* Setup initial PHY config & startup aneg */
-        if (ep->phy_mii.def->ops->init)
-                ep->phy_mii.def->ops->init(&ep->phy_mii);
-        netif_carrier_off(ndev);
-        if (ep->phy_mii.def->features & SUPPORTED_Autoneg)
-                ep->want_autoneg = 1;
-        else {
-                ep->want_autoneg = 0;
+                /* Init PHY */
+                if (dev->phy.def->ops->init)
+                        dev->phy.def->ops->init(&dev->phy);
                 
-                /* Select highest supported speed/duplex */
-                if (ep->phy_mii.def->features & SUPPORTED_1000baseT_Full) {
-                        ep->phy_mii.speed = SPEED_1000;
-                        ep->phy_mii.duplex = DUPLEX_FULL;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_1000baseT_Half) {
-                        ep->phy_mii.speed = SPEED_1000;
-                        ep->phy_mii.duplex = DUPLEX_HALF;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_100baseT_Full) {
-                        ep->phy_mii.speed = SPEED_100;
-                        ep->phy_mii.duplex = DUPLEX_FULL;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_100baseT_Half) {
-                        ep->phy_mii.speed = SPEED_100;
-                        ep->phy_mii.duplex = DUPLEX_HALF;
-                } else if (ep->phy_mii.def->features & 
-                           SUPPORTED_10baseT_Full) {
-                        ep->phy_mii.speed = SPEED_10;
-                        ep->phy_mii.duplex = DUPLEX_FULL;
+                /* Disable any PHY features not supported by the platform */
+                dev->phy.def->features &= ~emacdata->phy_feat_exc;
+
+                /* Setup initial link parameters */
+                if (dev->phy.features & SUPPORTED_Autoneg) {
+                        adv = dev->phy.features;
+#if !defined(CONFIG_40x)
+                        adv |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
+#endif
+                        /* Restart autonegotiation */
+                        dev->phy.def->ops->setup_aneg(&dev->phy, adv);
                 } else {
-                        ep->phy_mii.speed = SPEED_10;
-                        ep->phy_mii.duplex = DUPLEX_HALF;
+                        u32 f = dev->phy.def->features;
+                        int speed = SPEED_10, fd = DUPLEX_HALF;
+
+                        /* Select highest supported speed/duplex */
+                        if (f & SUPPORTED_1000baseT_Full) {
+                                speed = SPEED_1000;
+                                fd = DUPLEX_FULL;
+                        } else if (f & SUPPORTED_1000baseT_Half)
+                                speed = SPEED_1000;
+                        else if (f & SUPPORTED_100baseT_Full) {
+                                speed = SPEED_100;
+                                fd = DUPLEX_FULL;
+                        } else if (f & SUPPORTED_100baseT_Half)
+                                speed = SPEED_100;
+                        else if (f & SUPPORTED_10baseT_Full)
+                                fd = DUPLEX_FULL;
+
+                        /* Force link parameters */
+                        dev->phy.def->ops->setup_forced(&dev->phy, speed, fd);
                 }
-        }
-        emac_start_link(ep, NULL);
+        } else {
+                emac_reset(dev);
 
-        /* read the MAC Address */
-        for (i = 0; i < 6; i++)
-                ndev->dev_addr[i] = emacdata->mac_addr[i];
+                /* PHY-less configuration.
+                 * XXX I probably should move these settings to emacdata
+                 */
+                dev->phy.address = -1;
+                dev->phy.features = SUPPORTED_100baseT_Full | SUPPORTED_MII;
+                dev->phy.pause = 1;
+        }
 
         /* Fill in the driver function table */
         ndev->open = &emac_open;
-        ndev->hard_start_xmit = &emac_start_xmit;
+        if (dev->tah_dev) {
+                ndev->hard_start_xmit = &emac_start_xmit_sg;
+                ndev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
+        } else
+                ndev->hard_start_xmit = &emac_start_xmit;
+        ndev->tx_timeout = &emac_full_tx_reset;
+        ndev->watchdog_timeo = 5 * HZ;
         ndev->stop = &emac_close;
         ndev->get_stats = &emac_stats;
-        if (emacdata->jumbo)
-                ndev->change_mtu = &emac_change_mtu;
-        ndev->set_mac_address = &emac_set_mac_address;
         ndev->set_multicast_list = &emac_set_multicast_list;
         ndev->do_ioctl = &emac_ioctl;
+        if (emac_phy_supports_gige(emacdata->phy_mode)) {
+                ndev->change_mtu = &emac_change_mtu;
+                dev->commac.ops = &emac_commac_sg_ops;
+        }
         SET_ETHTOOL_OPS(ndev, &emac_ethtool_ops);
-        if (emacdata->tah_idx >= 0)
-                ndev->features = NETIF_F_IP_CSUM | NETIF_F_SG;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        ndev->poll_controller = emac_netpoll;
-#endif
 
-        SET_MODULE_OWNER(ndev);
+        netif_carrier_off(ndev);
+        netif_stop_queue(ndev);
+
+        err = register_netdev(ndev);
+        if (err) {
+                printk(KERN_ERR "emac%d: failed to register net device (%d)!\n",
+                       dev->def->index, err);
+                goto out6;
+        }
 
-        rc = register_netdev(ndev);
-        if (rc != 0)
-                goto bail;
+        ocp_set_drvdata(ocpdev, dev);
 
-        printk("%s: IBM emac, MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
-               ndev->name,
+        printk("%s: emac%d, MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+               ndev->name, dev->def->index,
                ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
                ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
-        printk(KERN_INFO "%s: Found %s PHY (0x%02x)\n",
-               ndev->name, ep->phy_mii.def->name, ep->mii_phy_addr);
 
-      bail:
-        if (rc && commac_reg)
-                mal_unregister_commac(ep->mal, &ep->commac);
-        if (rc && ndev)
-                kfree(ndev);
+        if (dev->phy.address >= 0)
+                printk("%s: found %s PHY (0x%02x)\n", ndev->name,
+                       dev->phy.def->name, dev->phy.address);
 
-        return rc;
-}
-
-static int emac_probe(struct ocp_device *ocpdev)
-{
-        struct ocp_device *maldev;
-        struct ibm_ocp_mal *mal;
-        struct ocp_func_emac_data *emacdata;
-
-        emacdata = (struct ocp_func_emac_data *)ocpdev->def->additions;
-        if (emacdata == NULL) {
-                printk(KERN_ERR "emac%d: Missing additional datas !\n",
-                       ocpdev->def->index);
-                return -ENODEV;
-        }
-
-        /* Get the MAL device  */
-        maldev = ocp_find_device(OCP_ANY_ID, OCP_FUNC_MAL, emacdata->mal_idx);
-        if (maldev == NULL) {
-                printk("No maldev\n");
-                return -ENODEV;
-        }
-        /*
-         * Get MAL driver data, it must be here due to link order.
-         * When the driver is modularized, symbol dependencies will
-         * ensure the MAL driver is already present if built as a
-         * module.
-         */
-        mal = (struct ibm_ocp_mal *)ocp_get_drvdata(maldev);
-        if (mal == NULL) {
-                printk("No maldrv\n");
-                return -ENODEV;
-        }
-
-        /* If we depend on another EMAC for MDIO, wait for it to show up */
-        if (emacdata->mdio_idx >= 0 &&
-            (emacdata->mdio_idx != ocpdev->def->index) && !mdio_ndev) {
-                struct emac_def_dev *ddev;
-                /* Add this index to the deferred init table */
-                ddev = kmalloc(sizeof(struct emac_def_dev), GFP_KERNEL);
-                ddev->ocpdev = ocpdev;
-                ddev->mal = mal;
-                list_add_tail(&ddev->link, &emac_init_list);
-        } else {
-                emac_init_device(ocpdev, mal);
-        }
+        emac_dbg_register(dev->def->index, dev);
 
         return 0;
+      out6:
+        iounmap((void *)dev->emacp);
+      out5:
+        tah_fini(dev->tah_dev);
+      out4:
+        rgmii_fini(dev->rgmii_dev, dev->rgmii_input);
+      out3:
+        zmii_fini(dev->zmii_dev, dev->zmii_input);
+      out2:
+        mal_unregister_commac(dev->mal, &dev->commac);
+      out:
+        kfree(ndev);
+        return err;
 }
 
-/* Structure for a device driver */
 static struct ocp_device_id emac_ids[] = {
-        {.vendor = OCP_ANY_ID,.function = OCP_FUNC_EMAC},
-        {.vendor = OCP_VENDOR_INVALID}
+        { .vendor = OCP_VENDOR_IBM, .function = OCP_FUNC_EMAC },
+        { .vendor = OCP_VENDOR_INVALID}
 };
 
 static struct ocp_driver emac_driver = {
         .name = "emac",
         .id_table = emac_ids,
-
         .probe = emac_probe,
         .remove = emac_remove,
 };
 
 static int __init emac_init(void)
 {
-        printk(KERN_INFO DRV_NAME ": " DRV_DESC ", version " DRV_VERSION "\n");
-        printk(KERN_INFO "Maintained by " DRV_AUTHOR "\n");
+        printk(KERN_INFO DRV_DESC ", version " DRV_VERSION "\n");
+
+        DBG(": init" NL);
 
-        if (skb_res > 2) {
-                printk(KERN_WARNING "Invalid skb_res: %d, cropping to 2\n",
-                       skb_res);
-                skb_res = 2;
+        if (mal_init())
+                return -ENODEV;
+
+        EMAC_CLK_INTERNAL;
+        if (ocp_register_driver(&emac_driver)) {
+                EMAC_CLK_EXTERNAL;
+                ocp_unregister_driver(&emac_driver);
+                mal_exit();
+                return -ENODEV;
         }
+        EMAC_CLK_EXTERNAL;
 
-        return ocp_register_driver(&emac_driver);
+        emac_init_debug();
+        return 0;
 }
 
 static void __exit emac_exit(void)
 {
+        DBG(": exit" NL);
         ocp_unregister_driver(&emac_driver);
+        mal_exit();
+        emac_fini_debug();
 }
 
 module_init(emac_init);
diff --git a/drivers/net/ibm_emac/ibm_emac_core.h b/drivers/net/ibm_emac/ibm_emac_core.h
index 97e6e1ea8c89..e9b44d030ac3 100644
--- a/drivers/net/ibm_emac/ibm_emac_core.h
+++ b/drivers/net/ibm_emac/ibm_emac_core.h
@@ -1,146 +1,221 @@
 /*
- * ibm_emac_core.h
+ * drivers/net/ibm_emac/ibm_emac_core.h
  *
- * Ethernet driver for the built in ethernet on the IBM 405 PowerPC
- * processor.
+ * Driver for PowerPC 4xx on-chip ethernet controller.
  *
- *      Armin Kuster akuster@mvista.com
- *      Sept, 2001
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- *      Orignial driver
- *         Johnnie Peters
- *         jpeters@mvista.com
- *
- * Copyright 2000 MontaVista Softare Inc.
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Johnnie Peters <jpeters@mvista.com>
+ *      Copyright 2000, 2001 MontaVista Softare Inc.
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
  * Free Software Foundation;  either version 2 of the  License, or (at your
  * option) any later version.
+ *
  */
+#ifndef __IBM_EMAC_CORE_H_
+#define __IBM_EMAC_CORE_H_
 
-#ifndef _IBM_EMAC_CORE_H_
-#define _IBM_EMAC_CORE_H_
-
+#include <linux/config.h>
 #include <linux/netdevice.h>
+#include <linux/dma-mapping.h>
 #include <asm/ocp.h>
-#include <asm/mmu.h>            /* For phys_addr_t */
 
 #include "ibm_emac.h"
 #include "ibm_emac_phy.h"
-#include "ibm_emac_rgmii.h"
 #include "ibm_emac_zmii.h"
+#include "ibm_emac_rgmii.h"
 #include "ibm_emac_mal.h"
 #include "ibm_emac_tah.h"
 
-#ifndef CONFIG_IBM_EMAC_TXB
-#define NUM_TX_BUFF             64
-#define NUM_RX_BUFF             64
-#else
-#define NUM_TX_BUFF             CONFIG_IBM_EMAC_TXB
-#define NUM_RX_BUFF             CONFIG_IBM_EMAC_RXB
-#endif
+#define NUM_TX_BUFF                     CONFIG_IBM_EMAC_TXB
+#define NUM_RX_BUFF                     CONFIG_IBM_EMAC_RXB
 
-/* This does 16 byte alignment, exactly what we need.
- * The packet length includes FCS, but we don't want to
- * include that when passing upstream as it messes up
- * bridging applications.
- */
-#ifndef CONFIG_IBM_EMAC_SKBRES
-#define SKB_RES 2
-#else
-#define SKB_RES CONFIG_IBM_EMAC_SKBRES
+/* Simple sanity check */
+#if NUM_TX_BUFF > 256 || NUM_RX_BUFF > 256
+#error Invalid number of buffer descriptors (greater than 256)
 #endif
 
-/* Note about alignement. alloc_skb() returns a cache line
- * aligned buffer. However, dev_alloc_skb() will add 16 more
- * bytes and "reserve" them, so our buffer will actually end
- * on a half cache line. What we do is to use directly
- * alloc_skb, allocate 16 more bytes to match the total amount
- * allocated by dev_alloc_skb(), but we don't reserve.
+// XXX
+#define EMAC_MIN_MTU                    46
+#define EMAC_MAX_MTU                    9000
+
+/* Maximum L2 header length (VLAN tagged, no FCS) */
+#define EMAC_MTU_OVERHEAD               (6 * 2 + 2 + 4)
+
+/* RX BD size for the given MTU */
+static inline int emac_rx_size(int mtu)
+{
+        if (mtu > ETH_DATA_LEN)
+                return MAL_MAX_RX_SIZE;
+        else
+                return mal_rx_size(ETH_DATA_LEN + EMAC_MTU_OVERHEAD);
+}
+
+#define EMAC_DMA_ALIGN(x)               ALIGN((x), dma_get_cache_alignment())
+
+#define EMAC_RX_SKB_HEADROOM            \
+        EMAC_DMA_ALIGN(CONFIG_IBM_EMAC_RX_SKB_HEADROOM)
+
+/* Size of RX skb for the given MTU */
+static inline int emac_rx_skb_size(int mtu)
+{
+        int size = max(mtu + EMAC_MTU_OVERHEAD, emac_rx_size(mtu));
+        return EMAC_DMA_ALIGN(size + 2) + EMAC_RX_SKB_HEADROOM;
+}
+
+/* RX DMA sync size */
+static inline int emac_rx_sync_size(int mtu)
+{
+        return EMAC_DMA_ALIGN(emac_rx_size(mtu) + 2);
+}
+
+/* Driver statistcs is split into two parts to make it more cache friendly:
+ *   - normal statistics (packet count, etc)
+ *   - error statistics
+ *
+ * When statistics is requested by ethtool, these parts are concatenated,
+ * normal one goes first.
+ *
+ * Please, keep these structures in sync with emac_stats_keys.
  */
-#define MAX_NUM_BUF_DESC        255
-#define DESC_BUF_SIZE           4080    /* max 4096-16 */
-#define DESC_BUF_SIZE_REG       (DESC_BUF_SIZE / 16)
-
-/* Transmitter timeout. */
-#define TX_TIMEOUT              (2*HZ)
-
-/* MDIO latency delay */
-#define MDIO_DELAY              250
-
-/* Power managment shift registers */
-#define IBM_CPM_EMMII   0       /* Shift value for MII */
-#define IBM_CPM_EMRX    1       /* Shift value for recv */
-#define IBM_CPM_EMTX    2       /* Shift value for MAC */
-#define IBM_CPM_EMAC(x) (((x)>>IBM_CPM_EMMII) | ((x)>>IBM_CPM_EMRX) | ((x)>>IBM_CPM_EMTX))
-
-#define ENET_HEADER_SIZE        14
-#define ENET_FCS_SIZE           4
-#define ENET_DEF_MTU_SIZE       1500
-#define ENET_DEF_BUF_SIZE       (ENET_DEF_MTU_SIZE + ENET_HEADER_SIZE + ENET_FCS_SIZE)
-#define EMAC_MIN_FRAME          64
-#define EMAC_MAX_FRAME          9018
-#define EMAC_MIN_MTU            (EMAC_MIN_FRAME - ENET_HEADER_SIZE - ENET_FCS_SIZE)
-#define EMAC_MAX_MTU            (EMAC_MAX_FRAME - ENET_HEADER_SIZE - ENET_FCS_SIZE)
-
-#ifdef CONFIG_IBM_EMAC_ERRMSG
-void emac_serr_dump_0(struct net_device *dev);
-void emac_serr_dump_1(struct net_device *dev);
-void emac_err_dump(struct net_device *dev, int em0isr);
-void emac_phy_dump(struct net_device *);
-void emac_desc_dump(struct net_device *);
-void emac_mac_dump(struct net_device *);
-void emac_mal_dump(struct net_device *);
-#else
-#define emac_serr_dump_0(dev) do { } while (0)
-#define emac_serr_dump_1(dev) do { } while (0)
-#define emac_err_dump(dev,x) do { } while (0)
-#define emac_phy_dump(dev) do { } while (0)
-#define emac_desc_dump(dev) do { } while (0)
-#define emac_mac_dump(dev) do { } while (0)
-#define emac_mal_dump(dev) do { } while (0)
-#endif
+
+/* Normal TX/RX Statistics */
+struct ibm_emac_stats {
+        u64 rx_packets;
+        u64 rx_bytes;
+        u64 tx_packets;
+        u64 tx_bytes;
+        u64 rx_packets_csum;
+        u64 tx_packets_csum;
+};
+
+/* Error statistics */
+struct ibm_emac_error_stats {
+        u64 tx_undo;
+
+        /* Software RX Errors */
+        u64 rx_dropped_stack;
+        u64 rx_dropped_oom;
+        u64 rx_dropped_error;
+        u64 rx_dropped_resize;
+        u64 rx_dropped_mtu;
+        u64 rx_stopped;
+        /* BD reported RX errors */
+        u64 rx_bd_errors;
+        u64 rx_bd_overrun;
+        u64 rx_bd_bad_packet;
+        u64 rx_bd_runt_packet;
+        u64 rx_bd_short_event;
+        u64 rx_bd_alignment_error;
+        u64 rx_bd_bad_fcs;
+        u64 rx_bd_packet_too_long;
+        u64 rx_bd_out_of_range;
+        u64 rx_bd_in_range;
+        /* EMAC IRQ reported RX errors */
+        u64 rx_parity;
+        u64 rx_fifo_overrun;
+        u64 rx_overrun;
+        u64 rx_bad_packet;
+        u64 rx_runt_packet;
+        u64 rx_short_event;
+        u64 rx_alignment_error;
+        u64 rx_bad_fcs;
+        u64 rx_packet_too_long;
+        u64 rx_out_of_range;
+        u64 rx_in_range;
+
+        /* Software TX Errors */
+        u64 tx_dropped;
+        /* BD reported TX errors */
+        u64 tx_bd_errors;
+        u64 tx_bd_bad_fcs;
+        u64 tx_bd_carrier_loss;
+        u64 tx_bd_excessive_deferral;
+        u64 tx_bd_excessive_collisions;
+        u64 tx_bd_late_collision;
+        u64 tx_bd_multple_collisions;
+        u64 tx_bd_single_collision;
+        u64 tx_bd_underrun;
+        u64 tx_bd_sqe;
+        /* EMAC IRQ reported TX errors */
+        u64 tx_parity;
+        u64 tx_underrun;
+        u64 tx_sqe;
+        u64 tx_errors;
+};
+
+#define EMAC_ETHTOOL_STATS_COUNT        ((sizeof(struct ibm_emac_stats) + \
+                                          sizeof(struct ibm_emac_error_stats)) \
+                                         / sizeof(u64))
 
 struct ocp_enet_private {
-        struct sk_buff *tx_skb[NUM_TX_BUFF];
-        struct sk_buff *rx_skb[NUM_RX_BUFF];
-        struct mal_descriptor *tx_desc;
-        struct mal_descriptor *rx_desc;
-        struct mal_descriptor *rx_dirty;
-        struct net_device_stats stats;
-        int tx_cnt;
-        int rx_slot;
-        int dirty_rx;
-        int tx_slot;
-        int ack_slot;
-        int rx_buffer_size;
-
-        struct mii_phy phy_mii;
-        int mii_phy_addr;
-        int want_autoneg;
-        int timer_ticks;
-        struct timer_list link_timer;
-        struct net_device *mdio_dev;
-
-        struct ocp_device *rgmii_dev;
-        int rgmii_input;
-
-        struct ocp_device *zmii_dev;
-        int zmii_input;
-
-        struct ibm_ocp_mal *mal;
-        int mal_tx_chan, mal_rx_chan;
-        struct mal_commac commac;
-
-        struct ocp_device *tah_dev;
-
-        int opened;
-        int going_away;
-        int wol_irq;
-        emac_t *emacp;
-        struct ocp_device *ocpdev;
-        struct net_device *ndev;
-        spinlock_t lock;
+        struct net_device               *ndev;          /* 0 */
+        struct emac_regs                *emacp;
+        
+        struct mal_descriptor           *tx_desc;
+        int                             tx_cnt;
+        int                             tx_slot;
+        int                             ack_slot;
+
+        struct mal_descriptor           *rx_desc;
+        int                             rx_slot;
+        struct sk_buff                  *rx_sg_skb;     /* 1 */
+        int                             rx_skb_size;
+        int                             rx_sync_size;
+
+        struct ibm_emac_stats           stats;
+        struct ocp_device               *tah_dev;
+
+        struct ibm_ocp_mal              *mal;
+        struct mal_commac               commac;
+
+        struct sk_buff                  *tx_skb[NUM_TX_BUFF];
+        struct sk_buff                  *rx_skb[NUM_RX_BUFF];
+
+        struct ocp_device               *zmii_dev;
+        int                             zmii_input;
+        struct ocp_enet_private         *mdio_dev;
+        struct ocp_device               *rgmii_dev;
+        int                             rgmii_input;
+
+        struct ocp_def                  *def;
+
+        struct mii_phy                  phy;
+        struct timer_list               link_timer;
+        int                             reset_failed;
+
+        struct ibm_emac_error_stats     estats;
+        struct net_device_stats         nstats;
+
+        struct device*                  ldev;
 };
-#endif                          /* _IBM_EMAC_CORE_H_ */
+
+/* Ethtool get_regs complex data.
+ * We want to get not just EMAC registers, but also MAL, ZMII, RGMII, TAH 
+ * when available.
+ * 
+ * Returned BLOB consists of the ibm_emac_ethtool_regs_hdr, 
+ * MAL registers, EMAC registers and optional ZMII, RGMII, TAH registers.
+ * Each register component is preceded with emac_ethtool_regs_subhdr.
+ * Order of the optional headers follows their relative bit posititions 
+ * in emac_ethtool_regs_hdr.components
+ */
+#define EMAC_ETHTOOL_REGS_ZMII          0x00000001
+#define EMAC_ETHTOOL_REGS_RGMII         0x00000002
+#define EMAC_ETHTOOL_REGS_TAH           0x00000004
+
+struct emac_ethtool_regs_hdr {
+        u32 components;
+};
+
+struct emac_ethtool_regs_subhdr {
+        u32 version;
+        u32 index;
+};
+
+#endif                          /* __IBM_EMAC_CORE_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_debug.c b/drivers/net/ibm_emac/ibm_emac_debug.c
index c8512046cf84..75d3b8639041 100644
--- a/drivers/net/ibm_emac/ibm_emac_debug.c
+++ b/drivers/net/ibm_emac/ibm_emac_debug.c
@@ -1,224 +1,213 @@
 /*
- * ibm_ocp_debug.c
+ * drivers/net/ibm_emac/ibm_emac_debug.c
  *
- * This has all the debug routines that where in *_enet.c
+ * Driver for PowerPC 4xx on-chip ethernet controller, debug print routines.
  *
- *      Armin Kuster akuster@mvista.com
- *      April , 2002
- *
- * Copyright 2002 MontaVista Softare Inc.
+ * Copyright (c) 2004, 2005 Zultys Technologies
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
  * 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/config.h>
+#include <linux/init.h>
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/sysrq.h>
 #include <asm/io.h>
-#include "ibm_ocp_mal.h"
-#include "ibm_ocp_zmii.h"
-#include "ibm_ocp_enet.h"
 
-extern int emac_phy_read(struct net_device *dev, int mii_id, int reg);
+#include "ibm_emac_core.h"
+
+static void emac_desc_dump(int idx, struct ocp_enet_private *p)
+{
+        int i;
+        printk("** EMAC%d TX BDs **\n"
+               " tx_cnt = %d tx_slot = %d ack_slot = %d\n",
+               idx, p->tx_cnt, p->tx_slot, p->ack_slot);
+        for (i = 0; i < NUM_TX_BUFF / 2; ++i)
+                printk
+                    ("bd[%2d] 0x%08x %c 0x%04x %4u - bd[%2d] 0x%08x %c 0x%04x %4u\n",
+                     i, p->tx_desc[i].data_ptr, p->tx_skb[i] ? 'V' : ' ',
+                     p->tx_desc[i].ctrl, p->tx_desc[i].data_len,
+                     NUM_TX_BUFF / 2 + i,
+                     p->tx_desc[NUM_TX_BUFF / 2 + i].data_ptr,
+                     p->tx_skb[NUM_TX_BUFF / 2 + i] ? 'V' : ' ',
+                     p->tx_desc[NUM_TX_BUFF / 2 + i].ctrl,
+                     p->tx_desc[NUM_TX_BUFF / 2 + i].data_len);
+
+        printk("** EMAC%d RX BDs **\n"
+               " rx_slot = %d rx_stopped = %d rx_skb_size = %d rx_sync_size = %d\n"
+               " rx_sg_skb = 0x%p\n",
+               idx, p->rx_slot, p->commac.rx_stopped, p->rx_skb_size,
+               p->rx_sync_size, p->rx_sg_skb);
+        for (i = 0; i < NUM_RX_BUFF / 2; ++i)
+                printk
+                    ("bd[%2d] 0x%08x %c 0x%04x %4u - bd[%2d] 0x%08x %c 0x%04x %4u\n",
+                     i, p->rx_desc[i].data_ptr, p->rx_skb[i] ? 'V' : ' ',
+                     p->rx_desc[i].ctrl, p->rx_desc[i].data_len,
+                     NUM_RX_BUFF / 2 + i,
+                     p->rx_desc[NUM_RX_BUFF / 2 + i].data_ptr,
+                     p->rx_skb[NUM_RX_BUFF / 2 + i] ? 'V' : ' ',
+                     p->rx_desc[NUM_RX_BUFF / 2 + i].ctrl,
+                     p->rx_desc[NUM_RX_BUFF / 2 + i].data_len);
+}
+
+static void emac_mac_dump(int idx, struct ocp_enet_private *dev)
+{
+        struct emac_regs *p = dev->emacp;
+
+        printk("** EMAC%d registers **\n"
+               "MR0 = 0x%08x MR1 = 0x%08x TMR0 = 0x%08x TMR1 = 0x%08x\n"
+               "RMR = 0x%08x ISR = 0x%08x ISER = 0x%08x\n"
+               "IAR = %04x%08x VTPID = 0x%04x VTCI = 0x%04x\n"
+               "IAHT: 0x%04x 0x%04x 0x%04x 0x%04x "
+               "GAHT: 0x%04x 0x%04x 0x%04x 0x%04x\n"
+               "LSA = %04x%08x IPGVR = 0x%04x\n"
+               "STACR = 0x%08x TRTR = 0x%08x RWMR = 0x%08x\n"
+               "OCTX = 0x%08x OCRX = 0x%08x IPCR = 0x%08x\n",
+               idx, in_be32(&p->mr0), in_be32(&p->mr1),
+               in_be32(&p->tmr0), in_be32(&p->tmr1),
+               in_be32(&p->rmr), in_be32(&p->isr), in_be32(&p->iser),
+               in_be32(&p->iahr), in_be32(&p->ialr), in_be32(&p->vtpid),
+               in_be32(&p->vtci),
+               in_be32(&p->iaht1), in_be32(&p->iaht2), in_be32(&p->iaht3),
+               in_be32(&p->iaht4),
+               in_be32(&p->gaht1), in_be32(&p->gaht2), in_be32(&p->gaht3),
+               in_be32(&p->gaht4),
+               in_be32(&p->lsah), in_be32(&p->lsal), in_be32(&p->ipgvr),
+               in_be32(&p->stacr), in_be32(&p->trtr), in_be32(&p->rwmr),
+               in_be32(&p->octx), in_be32(&p->ocrx), in_be32(&p->ipcr)
+            );
+
+        emac_desc_dump(idx, dev);
+}
+
+static void emac_mal_dump(struct ibm_ocp_mal *mal)
+{
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        int i;
+
+        printk("** MAL%d Registers **\n"
+               "CFG = 0x%08x ESR = 0x%08x IER = 0x%08x\n"
+               "TX|CASR = 0x%08x CARR = 0x%08x EOBISR = 0x%08x DEIR = 0x%08x\n"
+               "RX|CASR = 0x%08x CARR = 0x%08x EOBISR = 0x%08x DEIR = 0x%08x\n",
+               mal->def->index,
+               get_mal_dcrn(mal, MAL_CFG), get_mal_dcrn(mal, MAL_ESR),
+               get_mal_dcrn(mal, MAL_IER),
+               get_mal_dcrn(mal, MAL_TXCASR), get_mal_dcrn(mal, MAL_TXCARR),
+               get_mal_dcrn(mal, MAL_TXEOBISR), get_mal_dcrn(mal, MAL_TXDEIR),
+               get_mal_dcrn(mal, MAL_RXCASR), get_mal_dcrn(mal, MAL_RXCARR),
+               get_mal_dcrn(mal, MAL_RXEOBISR), get_mal_dcrn(mal, MAL_RXDEIR)
+            );
+
+        printk("TX|");
+        for (i = 0; i < maldata->num_tx_chans; ++i) {
+                if (i && !(i % 4))
+                        printk("\n   ");
+                printk("CTP%d = 0x%08x ", i, get_mal_dcrn(mal, MAL_TXCTPR(i)));
+        }
+        printk("\nRX|");
+        for (i = 0; i < maldata->num_rx_chans; ++i) {
+                if (i && !(i % 4))
+                        printk("\n   ");
+                printk("CTP%d = 0x%08x ", i, get_mal_dcrn(mal, MAL_RXCTPR(i)));
+        }
+        printk("\n   ");
+        for (i = 0; i < maldata->num_rx_chans; ++i) {
+                u32 r = get_mal_dcrn(mal, MAL_RCBS(i));
+                if (i && !(i % 3))
+                        printk("\n   ");
+                printk("RCBS%d = 0x%08x (%d) ", i, r, r * 16);
+        }
+        printk("\n");
+}
+
+static struct ocp_enet_private *__emacs[4];
+static struct ibm_ocp_mal *__mals[1];
 
-void emac_phy_dump(struct net_device *dev)
+void emac_dbg_register(int idx, struct ocp_enet_private *dev)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        unsigned long i;
-        uint data;
-
-        printk(KERN_DEBUG " Prepare for Phy dump....\n");
-        for (i = 0; i < 0x1A; i++) {
-                data = emac_phy_read(dev, fep->mii_phy_addr, i);
-                printk(KERN_DEBUG "Phy reg 0x%lx ==> %4x\n", i, data);
-                if (i == 0x07)
-                        i = 0x0f;
+        unsigned long flags;
+
+        if (idx >= sizeof(__emacs) / sizeof(__emacs[0])) {
+                printk(KERN_WARNING
+                       "invalid index %d when registering EMAC for debugging\n",
+                       idx);
+                return;
         }
+
+        local_irq_save(flags);
+        __emacs[idx] = dev;
+        local_irq_restore(flags);
 }
 
-void emac_desc_dump(struct net_device *dev)
+void mal_dbg_register(int idx, struct ibm_ocp_mal *mal)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        int curr_slot;
-
-        printk(KERN_DEBUG
-               "dumping the receive descriptors:  current slot is %d\n",
-               fep->rx_slot);
-        for (curr_slot = 0; curr_slot < NUM_RX_BUFF; curr_slot++) {
-                printk(KERN_DEBUG
-                       "Desc %02d: status 0x%04x, length %3d, addr 0x%x\n",
-                       curr_slot, fep->rx_desc[curr_slot].ctrl,
-                       fep->rx_desc[curr_slot].data_len,
-                       (unsigned int)fep->rx_desc[curr_slot].data_ptr);
+        unsigned long flags;
+
+        if (idx >= sizeof(__mals) / sizeof(__mals[0])) {
+                printk(KERN_WARNING
+                       "invalid index %d when registering MAL for debugging\n",
+                       idx);
+                return;
         }
+
+        local_irq_save(flags);
+        __mals[idx] = mal;
+        local_irq_restore(flags);
 }
 
-void emac_mac_dump(struct net_device *dev)
+void emac_dbg_dump_all(void)
 {
-        struct ocp_enet_private *fep = dev->priv;
-        volatile emac_t *emacp = fep->emacp;
-
-        printk(KERN_DEBUG "EMAC DEBUG ********** \n");
-        printk(KERN_DEBUG "EMAC_M0  ==> 0x%x\n", in_be32(&emacp->em0mr0));
-        printk(KERN_DEBUG "EMAC_M1  ==> 0x%x\n", in_be32(&emacp->em0mr1));
-        printk(KERN_DEBUG "EMAC_TXM0==> 0x%x\n", in_be32(&emacp->em0tmr0));
-        printk(KERN_DEBUG "EMAC_TXM1==> 0x%x\n", in_be32(&emacp->em0tmr1));
-        printk(KERN_DEBUG "EMAC_RXM ==> 0x%x\n", in_be32(&emacp->em0rmr));
-        printk(KERN_DEBUG "EMAC_ISR ==> 0x%x\n", in_be32(&emacp->em0isr));
-        printk(KERN_DEBUG "EMAC_IER ==> 0x%x\n", in_be32(&emacp->em0iser));
-        printk(KERN_DEBUG "EMAC_IAH ==> 0x%x\n", in_be32(&emacp->em0iahr));
-        printk(KERN_DEBUG "EMAC_IAL ==> 0x%x\n", in_be32(&emacp->em0ialr));
-        printk(KERN_DEBUG "EMAC_VLAN_TPID_REG ==> 0x%x\n",
-               in_be32(&emacp->em0vtpid));
+        unsigned int i;
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        for (i = 0; i < sizeof(__mals) / sizeof(__mals[0]); ++i)
+                if (__mals[i])
+                        emac_mal_dump(__mals[i]);
+
+        for (i = 0; i < sizeof(__emacs) / sizeof(__emacs[0]); ++i)
+                if (__emacs[i])
+                        emac_mac_dump(i, __emacs[i]);
+
+        local_irq_restore(flags);
 }
 
-void emac_mal_dump(struct net_device *dev)
+#if defined(CONFIG_MAGIC_SYSRQ)
+static void emac_sysrq_handler(int key, struct pt_regs *pt_regs,
+                               struct tty_struct *tty)
 {
-        struct ibm_ocp_mal *mal = ((struct ocp_enet_private *)dev->priv)->mal;
-
-        printk(KERN_DEBUG " MAL DEBUG ********** \n");
-        printk(KERN_DEBUG " MCR      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALCR));
-        printk(KERN_DEBUG " ESR      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALESR));
-        printk(KERN_DEBUG " IER      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALIER));
-#ifdef CONFIG_40x
-        printk(KERN_DEBUG " DBR      ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALDBR));
-#endif                          /* CONFIG_40x */
-        printk(KERN_DEBUG " TXCASR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCASR));
-        printk(KERN_DEBUG " TXCARR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCARR));
-        printk(KERN_DEBUG " TXEOBISR ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXEOBISR));
-        printk(KERN_DEBUG " TXDEIR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXDEIR));
-        printk(KERN_DEBUG " RXCASR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCASR));
-        printk(KERN_DEBUG " RXCARR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCARR));
-        printk(KERN_DEBUG " RXEOBISR ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXEOBISR));
-        printk(KERN_DEBUG " RXDEIR   ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXDEIR));
-        printk(KERN_DEBUG " TXCTP0R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP0R));
-        printk(KERN_DEBUG " TXCTP1R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP1R));
-        printk(KERN_DEBUG " TXCTP2R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP2R));
-        printk(KERN_DEBUG " TXCTP3R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALTXCTP3R));
-        printk(KERN_DEBUG " RXCTP0R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCTP0R));
-        printk(KERN_DEBUG " RXCTP1R  ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRXCTP1R));
-        printk(KERN_DEBUG " RCBS0    ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRCBS0));
-        printk(KERN_DEBUG " RCBS1    ==> 0x%x\n",
-               (unsigned int)get_mal_dcrn(mal, DCRN_MALRCBS1));
+        emac_dbg_dump_all();
 }
 
-void emac_serr_dump_0(struct net_device *dev)
+static struct sysrq_key_op emac_sysrq_op = {
+        .handler = emac_sysrq_handler,
+        .help_msg = "emaC",
+        .action_msg = "Show EMAC(s) status",
+};
+
+int __init emac_init_debug(void)
 {
-        struct ibm_ocp_mal *mal = ((struct ocp_enet_private *)dev->priv)->mal;
-        unsigned long int mal_error, plb_error, plb_addr;
-
-        mal_error = get_mal_dcrn(mal, DCRN_MALESR);
-        printk(KERN_DEBUG "ppc405_eth_serr: %s channel %ld \n",
-               (mal_error & 0x40000000) ? "Receive" :
-               "Transmit", (mal_error & 0x3e000000) >> 25);
-        printk(KERN_DEBUG "  -----  latched error  -----\n");
-        if (mal_error & MALESR_DE)
-                printk(KERN_DEBUG "  DE: descriptor error\n");
-        if (mal_error & MALESR_OEN)
-                printk(KERN_DEBUG "  ONE: OPB non-fullword error\n");
-        if (mal_error & MALESR_OTE)
-                printk(KERN_DEBUG "  OTE: OPB timeout error\n");
-        if (mal_error & MALESR_OSE)
-                printk(KERN_DEBUG "  OSE: OPB slave error\n");
-
-        if (mal_error & MALESR_PEIN) {
-                plb_error = mfdcr(DCRN_PLB0_BESR);
-                printk(KERN_DEBUG
-                       "  PEIN: PLB error, PLB0_BESR is 0x%x\n",
-                       (unsigned int)plb_error);
-                plb_addr = mfdcr(DCRN_PLB0_BEAR);
-                printk(KERN_DEBUG
-                       "  PEIN: PLB error, PLB0_BEAR is 0x%x\n",
-                       (unsigned int)plb_addr);
-        }
+        return register_sysrq_key('c', &emac_sysrq_op);
 }
 
-void emac_serr_dump_1(struct net_device *dev)
+void __exit emac_fini_debug(void)
 {
-        struct ibm_ocp_mal *mal = ((struct ocp_enet_private *)dev->priv)->mal;
-        int mal_error = get_mal_dcrn(mal, DCRN_MALESR);
-
-        printk(KERN_DEBUG "  -----  cumulative errors  -----\n");
-        if (mal_error & MALESR_DEI)
-                printk(KERN_DEBUG "  DEI: descriptor error interrupt\n");
-        if (mal_error & MALESR_ONEI)
-                printk(KERN_DEBUG "  OPB non-fullword error interrupt\n");
-        if (mal_error & MALESR_OTEI)
-                printk(KERN_DEBUG "  OTEI: timeout error interrupt\n");
-        if (mal_error & MALESR_OSEI)
-                printk(KERN_DEBUG "  OSEI: slave error interrupt\n");
-        if (mal_error & MALESR_PBEI)
-                printk(KERN_DEBUG "  PBEI: PLB bus error interrupt\n");
+        unregister_sysrq_key('c', &emac_sysrq_op);
 }
 
-void emac_err_dump(struct net_device *dev, int em0isr)
+#else
+int __init emac_init_debug(void)
+{
+        return 0;
+}
+void __exit emac_fini_debug(void)
 {
-        printk(KERN_DEBUG "%s: on-chip ethernet error:\n", dev->name);
-
-        if (em0isr & EMAC_ISR_OVR)
-                printk(KERN_DEBUG "  OVR: overrun\n");
-        if (em0isr & EMAC_ISR_PP)
-                printk(KERN_DEBUG "  PP: control pause packet\n");
-        if (em0isr & EMAC_ISR_BP)
-                printk(KERN_DEBUG "  BP: packet error\n");
-        if (em0isr & EMAC_ISR_RP)
-                printk(KERN_DEBUG "  RP: runt packet\n");
-        if (em0isr & EMAC_ISR_SE)
-                printk(KERN_DEBUG "  SE: short event\n");
-        if (em0isr & EMAC_ISR_ALE)
-                printk(KERN_DEBUG "  ALE: odd number of nibbles in packet\n");
-        if (em0isr & EMAC_ISR_BFCS)
-                printk(KERN_DEBUG "  BFCS: bad FCS\n");
-        if (em0isr & EMAC_ISR_PTLE)
-                printk(KERN_DEBUG "  PTLE: oversized packet\n");
-        if (em0isr & EMAC_ISR_ORE)
-                printk(KERN_DEBUG
-                       "  ORE: packet length field > max allowed LLC\n");
-        if (em0isr & EMAC_ISR_IRE)
-                printk(KERN_DEBUG "  IRE: In Range error\n");
-        if (em0isr & EMAC_ISR_DBDM)
-                printk(KERN_DEBUG "  DBDM: xmit error or SQE\n");
-        if (em0isr & EMAC_ISR_DB0)
-                printk(KERN_DEBUG "  DB0: xmit error or SQE on TX channel 0\n");
-        if (em0isr & EMAC_ISR_SE0)
-                printk(KERN_DEBUG
-                       "  SE0: Signal Quality Error test failure from TX channel 0\n");
-        if (em0isr & EMAC_ISR_TE0)
-                printk(KERN_DEBUG "  TE0: xmit channel 0 aborted\n");
-        if (em0isr & EMAC_ISR_DB1)
-                printk(KERN_DEBUG "  DB1: xmit error or SQE on TX channel \n");
-        if (em0isr & EMAC_ISR_SE1)
-                printk(KERN_DEBUG
-                       "  SE1: Signal Quality Error test failure from TX channel 1\n");
-        if (em0isr & EMAC_ISR_TE1)
-                printk(KERN_DEBUG "  TE1: xmit channel 1 aborted\n");
-        if (em0isr & EMAC_ISR_MOS)
-                printk(KERN_DEBUG "  MOS\n");
-        if (em0isr & EMAC_ISR_MOF)
-                printk(KERN_DEBUG "  MOF\n");
-
-        emac_mac_dump(dev);
-        emac_mal_dump(dev);
 }
+#endif                          /* CONFIG_MAGIC_SYSRQ */
diff --git a/drivers/net/ibm_emac/ibm_emac_debug.h b/drivers/net/ibm_emac/ibm_emac_debug.h
new file mode 100644
index 000000000000..e85fbe0a8da9
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_debug.h
@@ -0,0 +1,63 @@
+/*
+ * drivers/net/ibm_emac/ibm_ocp_debug.h
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, debug print routines.
+ *
+ * Copyright (c) 2004, 2005 Zultys Technologies
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * 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 __IBM_EMAC_DEBUG_H_
+#define __IBM_EMAC_DEBUG_H_
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include "ibm_emac_core.h"
+#include "ibm_emac_mal.h"
+
+#if defined(CONFIG_IBM_EMAC_DEBUG)
+void emac_dbg_register(int idx, struct ocp_enet_private *dev);
+void mal_dbg_register(int idx, struct ibm_ocp_mal *mal);
+int emac_init_debug(void) __init;
+void emac_fini_debug(void) __exit;
+void emac_dbg_dump_all(void);
+# define DBG_LEVEL              1
+#else
+# define emac_dbg_register(x,y) ((void)0)
+# define mal_dbg_register(x,y)  ((void)0)
+# define emac_init_debug()      ((void)0)
+# define emac_fini_debug()      ((void)0)
+# define emac_dbg_dump_all()    ((void)0)
+# define DBG_LEVEL              0
+#endif
+
+#if DBG_LEVEL > 0
+#  define DBG(f,x...)           printk("emac" f, ##x)
+#  define MAL_DBG(f,x...)       printk("mal" f, ##x)
+#  define ZMII_DBG(f,x...)      printk("zmii" f, ##x)
+#  define RGMII_DBG(f,x...)     printk("rgmii" f, ##x)
+#  define NL                    "\n"
+#else
+#  define DBG(f,x...)           ((void)0)
+#  define MAL_DBG(f,x...)       ((void)0)
+#  define ZMII_DBG(f,x...)      ((void)0)
+#  define RGMII_DBG(f,x...)     ((void)0)
+#endif
+#if DBG_LEVEL > 1
+#  define DBG2(f,x...)          DBG(f, ##x)
+#  define MAL_DBG2(f,x...)      MAL_DBG(f, ##x)
+#  define ZMII_DBG2(f,x...)     ZMII_DBG(f, ##x)
+#  define RGMII_DBG2(f,x...)    RGMII_DBG(f, ##x)
+#else
+#  define DBG2(f,x...)          ((void)0)
+#  define MAL_DBG2(f,x...)      ((void)0)
+#  define ZMII_DBG2(f,x...)     ((void)0)
+#  define RGMII_DBG2(f,x...)    ((void)0)
+#endif
+
+#endif                          /* __IBM_EMAC_DEBUG_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_mal.c b/drivers/net/ibm_emac/ibm_emac_mal.c
index e59f57f363ca..da88d43081cc 100644
--- a/drivers/net/ibm_emac/ibm_emac_mal.c
+++ b/drivers/net/ibm_emac/ibm_emac_mal.c
@@ -1,436 +1,565 @@
 /*
- * ibm_ocp_mal.c
+ * drivers/net/ibm_emac/ibm_emac_mal.c
  *
- *      Armin Kuster akuster@mvista.com
- *      Juen, 2002
+ * Memory Access Layer (MAL) support
+ * 
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- * Copyright 2002 MontaVista Softare Inc.
+ * Based on original work by
+ *      Benjamin Herrenschmidt <benh@kernel.crashing.org>,
+ *      David Gibson <hermes@gibson.dropbear.id.au>,
+ *
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2002 MontaVista Softare Inc.
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
  * Free Software Foundation;  either version 2 of the  License, or (at your
  * option) any later version.
+ *
  */
-
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/netdevice.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 
-#include <asm/io.h>
-#include <asm/irq.h>
 #include <asm/ocp.h>
 
+#include "ibm_emac_core.h"
 #include "ibm_emac_mal.h"
+#include "ibm_emac_debug.h"
 
-// Locking: Should we share a lock with the client ? The client could provide
-// a lock pointer (optionally) in the commac structure... I don't think this is
-// really necessary though
-
-/* This lock protects the commac list. On today UP implementations, it's
- * really only used as IRQ protection in mal_{register,unregister}_commac()
- */
-static DEFINE_RWLOCK(mal_list_lock);
-
-int mal_register_commac(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+int __init mal_register_commac(struct ibm_ocp_mal *mal,
+                               struct mal_commac *commac)
 {
         unsigned long flags;
+        local_irq_save(flags);
 
-        write_lock_irqsave(&mal_list_lock, flags);
+        MAL_DBG("%d: reg(%08x, %08x)" NL, mal->def->index,
+                commac->tx_chan_mask, commac->rx_chan_mask);
 
-        /* Don't let multiple commacs claim the same channel */
+        /* Don't let multiple commacs claim the same channel(s) */
         if ((mal->tx_chan_mask & commac->tx_chan_mask) ||
             (mal->rx_chan_mask & commac->rx_chan_mask)) {
-                write_unlock_irqrestore(&mal_list_lock, flags);
+                local_irq_restore(flags);
+                printk(KERN_WARNING "mal%d: COMMAC channels conflict!\n",
+                       mal->def->index);
                 return -EBUSY;
         }
 
         mal->tx_chan_mask |= commac->tx_chan_mask;
         mal->rx_chan_mask |= commac->rx_chan_mask;
+        list_add(&commac->list, &mal->list);
 
-        list_add(&commac->list, &mal->commac);
-
-        write_unlock_irqrestore(&mal_list_lock, flags);
-
+        local_irq_restore(flags);
         return 0;
 }
 
-int mal_unregister_commac(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+void __exit mal_unregister_commac(struct ibm_ocp_mal *mal,
+                                  struct mal_commac *commac)
 {
         unsigned long flags;
+        local_irq_save(flags);
 
-        write_lock_irqsave(&mal_list_lock, flags);
+        MAL_DBG("%d: unreg(%08x, %08x)" NL, mal->def->index,
+                commac->tx_chan_mask, commac->rx_chan_mask);
 
         mal->tx_chan_mask &= ~commac->tx_chan_mask;
         mal->rx_chan_mask &= ~commac->rx_chan_mask;
-
         list_del_init(&commac->list);
 
-        write_unlock_irqrestore(&mal_list_lock, flags);
-
-        return 0;
+        local_irq_restore(flags);
 }
 
 int mal_set_rcbs(struct ibm_ocp_mal *mal, int channel, unsigned long size)
 {
-        switch (channel) {
-        case 0:
-                set_mal_dcrn(mal, DCRN_MALRCBS0, size);
-                break;
-#ifdef DCRN_MALRCBS1
-        case 1:
-                set_mal_dcrn(mal, DCRN_MALRCBS1, size);
-                break;
-#endif
-#ifdef DCRN_MALRCBS2
-        case 2:
-                set_mal_dcrn(mal, DCRN_MALRCBS2, size);
-                break;
-#endif
-#ifdef DCRN_MALRCBS3
-        case 3:
-                set_mal_dcrn(mal, DCRN_MALRCBS3, size);
-                break;
-#endif
-        default:
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        BUG_ON(channel < 0 || channel >= maldata->num_rx_chans ||
+               size > MAL_MAX_RX_SIZE);
+
+        MAL_DBG("%d: set_rbcs(%d, %lu)" NL, mal->def->index, channel, size);
+
+        if (size & 0xf) {
+                printk(KERN_WARNING
+                       "mal%d: incorrect RX size %lu for the channel %d\n",
+                       mal->def->index, size, channel);
                 return -EINVAL;
         }
 
+        set_mal_dcrn(mal, MAL_RCBS(channel), size >> 4);
         return 0;
 }
 
-static irqreturn_t mal_serr(int irq, void *dev_instance, struct pt_regs *regs)
+int mal_tx_bd_offset(struct ibm_ocp_mal *mal, int channel)
 {
-        struct ibm_ocp_mal *mal = dev_instance;
-        unsigned long mal_error;
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        BUG_ON(channel < 0 || channel >= maldata->num_tx_chans);
+        return channel * NUM_TX_BUFF;
+}
 
-        /*
-         * This SERR applies to one of the devices on the MAL, here we charge
-         * it against the first EMAC registered for the MAL.
-         */
+int mal_rx_bd_offset(struct ibm_ocp_mal *mal, int channel)
+{
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        BUG_ON(channel < 0 || channel >= maldata->num_rx_chans);
+        return maldata->num_tx_chans * NUM_TX_BUFF + channel * NUM_RX_BUFF;
+}
 
-        mal_error = get_mal_dcrn(mal, DCRN_MALESR);
+void mal_enable_tx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        local_bh_disable();
+        MAL_DBG("%d: enable_tx(%d)" NL, mal->def->index, channel);
+        set_mal_dcrn(mal, MAL_TXCASR,
+                     get_mal_dcrn(mal, MAL_TXCASR) | MAL_CHAN_MASK(channel));
+        local_bh_enable();
+}
 
-        printk(KERN_ERR "%s: System Error (MALESR=%lx)\n",
-               "MAL" /* FIXME: get the name right */ , mal_error);
+void mal_disable_tx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        set_mal_dcrn(mal, MAL_TXCARR, MAL_CHAN_MASK(channel));
+        MAL_DBG("%d: disable_tx(%d)" NL, mal->def->index, channel);
+}
 
-        /* FIXME: decipher error */
-        /* DIXME: distribute to commacs, if possible */
+void mal_enable_rx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        local_bh_disable();
+        MAL_DBG("%d: enable_rx(%d)" NL, mal->def->index, channel);
+        set_mal_dcrn(mal, MAL_RXCASR,
+                     get_mal_dcrn(mal, MAL_RXCASR) | MAL_CHAN_MASK(channel));
+        local_bh_enable();
+}
 
-        /* Clear the error status register */
-        set_mal_dcrn(mal, DCRN_MALESR, mal_error);
+void mal_disable_rx_channel(struct ibm_ocp_mal *mal, int channel)
+{
+        set_mal_dcrn(mal, MAL_RXCARR, MAL_CHAN_MASK(channel));
+        MAL_DBG("%d: disable_rx(%d)" NL, mal->def->index, channel);
+}
 
-        return IRQ_HANDLED;
+void mal_poll_add(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+{
+        local_bh_disable();
+        MAL_DBG("%d: poll_add(%p)" NL, mal->def->index, commac);
+        list_add_tail(&commac->poll_list, &mal->poll_list);
+        local_bh_enable();
 }
 
-static irqreturn_t mal_txeob(int irq, void *dev_instance, struct pt_regs *regs)
+void mal_poll_del(struct ibm_ocp_mal *mal, struct mal_commac *commac)
+{
+        local_bh_disable();
+        MAL_DBG("%d: poll_del(%p)" NL, mal->def->index, commac);
+        list_del(&commac->poll_list);
+        local_bh_enable();
+}
+
+/* synchronized by mal_poll() */
+static inline void mal_enable_eob_irq(struct ibm_ocp_mal *mal)
+{
+        MAL_DBG2("%d: enable_irq" NL, mal->def->index);
+        set_mal_dcrn(mal, MAL_CFG, get_mal_dcrn(mal, MAL_CFG) | MAL_CFG_EOPIE);
+}
+
+/* synchronized by __LINK_STATE_RX_SCHED bit in ndev->state */
+static inline void mal_disable_eob_irq(struct ibm_ocp_mal *mal)
+{
+        set_mal_dcrn(mal, MAL_CFG, get_mal_dcrn(mal, MAL_CFG) & ~MAL_CFG_EOPIE);
+        MAL_DBG2("%d: disable_irq" NL, mal->def->index);
+}
+
+static irqreturn_t mal_serr(int irq, void *dev_instance, struct pt_regs *regs)
 {
         struct ibm_ocp_mal *mal = dev_instance;
-        struct list_head *l;
-        unsigned long isr;
+        u32 esr = get_mal_dcrn(mal, MAL_ESR);
 
-        isr = get_mal_dcrn(mal, DCRN_MALTXEOBISR);
-        set_mal_dcrn(mal, DCRN_MALTXEOBISR, isr);
+        /* Clear the error status register */
+        set_mal_dcrn(mal, MAL_ESR, esr);
 
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
-                struct mal_commac *mc = list_entry(l, struct mal_commac, list);
+        MAL_DBG("%d: SERR %08x" NL, mal->def->index, esr);
 
-                if (isr & mc->tx_chan_mask) {
-                        mc->ops->txeob(mc->dev, isr & mc->tx_chan_mask);
+        if (esr & MAL_ESR_EVB) {
+                if (esr & MAL_ESR_DE) {
+                        /* We ignore Descriptor error,
+                         * TXDE or RXDE interrupt will be generated anyway.
+                         */
+                        return IRQ_HANDLED;
                 }
+
+                if (esr & MAL_ESR_PEIN) {
+                        /* PLB error, it's probably buggy hardware or
+                         * incorrect physical address in BD (i.e. bug)
+                         */
+                        if (net_ratelimit())
+                                printk(KERN_ERR
+                                       "mal%d: system error, PLB (ESR = 0x%08x)\n",
+                                       mal->def->index, esr);
+                        return IRQ_HANDLED;
+                }
+
+                /* OPB error, it's probably buggy hardware or incorrect EBC setup */
+                if (net_ratelimit())
+                        printk(KERN_ERR
+                               "mal%d: system error, OPB (ESR = 0x%08x)\n",
+                               mal->def->index, esr);
         }
-        read_unlock(&mal_list_lock);
+        return IRQ_HANDLED;
+}
+
+static inline void mal_schedule_poll(struct ibm_ocp_mal *mal)
+{
+        if (likely(netif_rx_schedule_prep(&mal->poll_dev))) {
+                MAL_DBG2("%d: schedule_poll" NL, mal->def->index);
+                mal_disable_eob_irq(mal);
+                __netif_rx_schedule(&mal->poll_dev);
+        } else
+                MAL_DBG2("%d: already in poll" NL, mal->def->index);
+}
 
+static irqreturn_t mal_txeob(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ibm_ocp_mal *mal = dev_instance;
+        u32 r = get_mal_dcrn(mal, MAL_TXEOBISR);
+        MAL_DBG2("%d: txeob %08x" NL, mal->def->index, r);
+        mal_schedule_poll(mal);
+        set_mal_dcrn(mal, MAL_TXEOBISR, r);
         return IRQ_HANDLED;
 }
 
 static irqreturn_t mal_rxeob(int irq, void *dev_instance, struct pt_regs *regs)
 {
         struct ibm_ocp_mal *mal = dev_instance;
-        struct list_head *l;
-        unsigned long isr;
+        u32 r = get_mal_dcrn(mal, MAL_RXEOBISR);
+        MAL_DBG2("%d: rxeob %08x" NL, mal->def->index, r);
+        mal_schedule_poll(mal);
+        set_mal_dcrn(mal, MAL_RXEOBISR, r);
+        return IRQ_HANDLED;
+}
 
-        isr = get_mal_dcrn(mal, DCRN_MALRXEOBISR);
-        set_mal_dcrn(mal, DCRN_MALRXEOBISR, isr);
+static irqreturn_t mal_txde(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ibm_ocp_mal *mal = dev_instance;
+        u32 deir = get_mal_dcrn(mal, MAL_TXDEIR);
+        set_mal_dcrn(mal, MAL_TXDEIR, deir);
 
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
-                struct mal_commac *mc = list_entry(l, struct mal_commac, list);
+        MAL_DBG("%d: txde %08x" NL, mal->def->index, deir);
 
-                if (isr & mc->rx_chan_mask) {
-                        mc->ops->rxeob(mc->dev, isr & mc->rx_chan_mask);
-                }
-        }
-        read_unlock(&mal_list_lock);
+        if (net_ratelimit())
+                printk(KERN_ERR
+                       "mal%d: TX descriptor error (TXDEIR = 0x%08x)\n",
+                       mal->def->index, deir);
 
         return IRQ_HANDLED;
 }
 
-static irqreturn_t mal_txde(int irq, void *dev_instance, struct pt_regs *regs)
+static irqreturn_t mal_rxde(int irq, void *dev_instance, struct pt_regs *regs)
 {
         struct ibm_ocp_mal *mal = dev_instance;
         struct list_head *l;
-        unsigned long deir;
+        u32 deir = get_mal_dcrn(mal, MAL_RXDEIR);
 
-        deir = get_mal_dcrn(mal, DCRN_MALTXDEIR);
+        MAL_DBG("%d: rxde %08x" NL, mal->def->index, deir);
 
-        /* FIXME: print which MAL correctly */
-        printk(KERN_WARNING "%s: Tx descriptor error (MALTXDEIR=%lx)\n",
-               "MAL", deir);
-
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
+        list_for_each(l, &mal->list) {
                 struct mal_commac *mc = list_entry(l, struct mal_commac, list);
-
-                if (deir & mc->tx_chan_mask) {
-                        mc->ops->txde(mc->dev, deir & mc->tx_chan_mask);
+                if (deir & mc->rx_chan_mask) {
+                        mc->rx_stopped = 1;
+                        mc->ops->rxde(mc->dev);
                 }
         }
-        read_unlock(&mal_list_lock);
+
+        mal_schedule_poll(mal);
+        set_mal_dcrn(mal, MAL_RXDEIR, deir);
 
         return IRQ_HANDLED;
 }
 
-/*
- * This interrupt should be very rare at best.  This occurs when
- * the hardware has a problem with the receive descriptors.  The manual
- * states that it occurs when the hardware cannot the receive descriptor
- * empty bit is not set.  The recovery mechanism will be to
- * traverse through the descriptors, handle any that are marked to be
- * handled and reinitialize each along the way.  At that point the driver
- * will be restarted.
- */
-static irqreturn_t mal_rxde(int irq, void *dev_instance, struct pt_regs *regs)
+static int mal_poll(struct net_device *ndev, int *budget)
 {
-        struct ibm_ocp_mal *mal = dev_instance;
+        struct ibm_ocp_mal *mal = ndev->priv;
         struct list_head *l;
-        unsigned long deir;
-
-        deir = get_mal_dcrn(mal, DCRN_MALRXDEIR);
+        int rx_work_limit = min(ndev->quota, *budget), received = 0, done;
+
+        MAL_DBG2("%d: poll(%d) %d ->" NL, mal->def->index, *budget,
+                 rx_work_limit);
+      again:
+        /* Process TX skbs */
+        list_for_each(l, &mal->poll_list) {
+                struct mal_commac *mc =
+                    list_entry(l, struct mal_commac, poll_list);
+                mc->ops->poll_tx(mc->dev);
+        }
 
-        /*
-         * This really is needed.  This case encountered in stress testing.
+        /* Process RX skbs.
+         * We _might_ need something more smart here to enforce polling fairness.
          */
-        if (deir == 0)
-                return IRQ_HANDLED;
-
-        /* FIXME: print which MAL correctly */
-        printk(KERN_WARNING "%s: Rx descriptor error (MALRXDEIR=%lx)\n",
-               "MAL", deir);
-
-        read_lock(&mal_list_lock);
-        list_for_each(l, &mal->commac) {
-                struct mal_commac *mc = list_entry(l, struct mal_commac, list);
+        list_for_each(l, &mal->poll_list) {
+                struct mal_commac *mc =
+                    list_entry(l, struct mal_commac, poll_list);
+                int n = mc->ops->poll_rx(mc->dev, rx_work_limit);
+                if (n) {
+                        received += n;
+                        rx_work_limit -= n;
+                        if (rx_work_limit <= 0) {
+                                done = 0;
+                                goto more_work; // XXX What if this is the last one ?
+                        }
+                }
+        }
 
-                if (deir & mc->rx_chan_mask) {
-                        mc->ops->rxde(mc->dev, deir & mc->rx_chan_mask);
+        /* We need to disable IRQs to protect from RXDE IRQ here */
+        local_irq_disable();
+        __netif_rx_complete(ndev);
+        mal_enable_eob_irq(mal);
+        local_irq_enable();
+
+        done = 1;
+
+        /* Check for "rotting" packet(s) */
+        list_for_each(l, &mal->poll_list) {
+                struct mal_commac *mc =
+                    list_entry(l, struct mal_commac, poll_list);
+                if (unlikely(mc->ops->peek_rx(mc->dev) || mc->rx_stopped)) {
+                        MAL_DBG2("%d: rotting packet" NL, mal->def->index);
+                        if (netif_rx_reschedule(ndev, received))
+                                mal_disable_eob_irq(mal);
+                        else
+                                MAL_DBG2("%d: already in poll list" NL,
+                                         mal->def->index);
+
+                        if (rx_work_limit > 0)
+                                goto again;
+                        else
+                                goto more_work;
                 }
+                mc->ops->poll_tx(mc->dev);
         }
-        read_unlock(&mal_list_lock);
 
-        return IRQ_HANDLED;
+      more_work:
+        ndev->quota -= received;
+        *budget -= received;
+
+        MAL_DBG2("%d: poll() %d <- %d" NL, mal->def->index, *budget,
+                 done ? 0 : 1);
+        return done ? 0 : 1;
+}
+
+static void mal_reset(struct ibm_ocp_mal *mal)
+{
+        int n = 10;
+        MAL_DBG("%d: reset" NL, mal->def->index);
+
+        set_mal_dcrn(mal, MAL_CFG, MAL_CFG_SR);
+
+        /* Wait for reset to complete (1 system clock) */
+        while ((get_mal_dcrn(mal, MAL_CFG) & MAL_CFG_SR) && n)
+                --n;
+
+        if (unlikely(!n))
+                printk(KERN_ERR "mal%d: reset timeout\n", mal->def->index);
+}
+
+int mal_get_regs_len(struct ibm_ocp_mal *mal)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct ibm_mal_regs);
+}
+
+void *mal_dump_regs(struct ibm_ocp_mal *mal, void *buf)
+{
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct ibm_mal_regs *regs = (struct ibm_mal_regs *)(hdr + 1);
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+        int i;
+
+        hdr->version = MAL_VERSION;
+        hdr->index = mal->def->index;
+
+        regs->tx_count = maldata->num_tx_chans;
+        regs->rx_count = maldata->num_rx_chans;
+
+        regs->cfg = get_mal_dcrn(mal, MAL_CFG);
+        regs->esr = get_mal_dcrn(mal, MAL_ESR);
+        regs->ier = get_mal_dcrn(mal, MAL_IER);
+        regs->tx_casr = get_mal_dcrn(mal, MAL_TXCASR);
+        regs->tx_carr = get_mal_dcrn(mal, MAL_TXCARR);
+        regs->tx_eobisr = get_mal_dcrn(mal, MAL_TXEOBISR);
+        regs->tx_deir = get_mal_dcrn(mal, MAL_TXDEIR);
+        regs->rx_casr = get_mal_dcrn(mal, MAL_RXCASR);
+        regs->rx_carr = get_mal_dcrn(mal, MAL_RXCARR);
+        regs->rx_eobisr = get_mal_dcrn(mal, MAL_RXEOBISR);
+        regs->rx_deir = get_mal_dcrn(mal, MAL_RXDEIR);
+
+        for (i = 0; i < regs->tx_count; ++i)
+                regs->tx_ctpr[i] = get_mal_dcrn(mal, MAL_TXCTPR(i));
+
+        for (i = 0; i < regs->rx_count; ++i) {
+                regs->rx_ctpr[i] = get_mal_dcrn(mal, MAL_RXCTPR(i));
+                regs->rcbs[i] = get_mal_dcrn(mal, MAL_RCBS(i));
+        }
+        return regs + 1;
 }
 
 static int __init mal_probe(struct ocp_device *ocpdev)
 {
-        struct ibm_ocp_mal *mal = NULL;
+        struct ibm_ocp_mal *mal;
         struct ocp_func_mal_data *maldata;
-        int err = 0;
+        int err = 0, i, bd_size;
+
+        MAL_DBG("%d: probe" NL, ocpdev->def->index);
 
-        maldata = (struct ocp_func_mal_data *)ocpdev->def->additions;
+        maldata = ocpdev->def->additions;
         if (maldata == NULL) {
-                printk(KERN_ERR "mal%d: Missing additional datas !\n",
+                printk(KERN_ERR "mal%d: missing additional data!\n",
                        ocpdev->def->index);
                 return -ENODEV;
         }
 
-        mal = kmalloc(sizeof(struct ibm_ocp_mal), GFP_KERNEL);
-        if (mal == NULL) {
+        mal = kzalloc(sizeof(struct ibm_ocp_mal), GFP_KERNEL);
+        if (!mal) {
                 printk(KERN_ERR
-                       "mal%d: Out of memory allocating MAL structure !\n",
+                       "mal%d: out of memory allocating MAL structure!\n",
                        ocpdev->def->index);
                 return -ENOMEM;
         }
-        memset(mal, 0, sizeof(*mal));
-
-        switch (ocpdev->def->index) {
-        case 0:
-                mal->dcrbase = DCRN_MAL_BASE;
-                break;
-#ifdef DCRN_MAL1_BASE
-        case 1:
-                mal->dcrbase = DCRN_MAL1_BASE;
-                break;
-#endif
-        default:
-                BUG();
-        }
-
-        /**************************/
+        mal->dcrbase = maldata->dcr_base;
+        mal->def = ocpdev->def;
 
-        INIT_LIST_HEAD(&mal->commac);
+        INIT_LIST_HEAD(&mal->poll_list);
+        set_bit(__LINK_STATE_START, &mal->poll_dev.state);
+        mal->poll_dev.weight = CONFIG_IBM_EMAC_POLL_WEIGHT;
+        mal->poll_dev.poll = mal_poll;
+        mal->poll_dev.priv = mal;
+        atomic_set(&mal->poll_dev.refcnt, 1);
 
-        set_mal_dcrn(mal, DCRN_MALRXCARR, 0xFFFFFFFF);
-        set_mal_dcrn(mal, DCRN_MALTXCARR, 0xFFFFFFFF);
+        INIT_LIST_HEAD(&mal->list);
 
-        set_mal_dcrn(mal, DCRN_MALCR, MALCR_MMSR);      /* 384 */
-        /* FIXME: Add delay */
+        /* Load power-on reset defaults */
+        mal_reset(mal);
 
         /* Set the MAL configuration register */
-        set_mal_dcrn(mal, DCRN_MALCR,
-                     MALCR_PLBB | MALCR_OPBBL | MALCR_LEA |
-                     MALCR_PLBLT_DEFAULT);
-
-        /* It would be nice to allocate buffers separately for each
-         * channel, but we can't because the channels share the upper
-         * 13 bits of address lines.  Each channels buffer must also
-         * be 4k aligned, so we allocate 4k for each channel.  This is
-         * inefficient FIXME: do better, if possible */
-        mal->tx_virt_addr = dma_alloc_coherent(&ocpdev->dev,
-                                               MAL_DT_ALIGN *
-                                               maldata->num_tx_chans,
-                                               &mal->tx_phys_addr, GFP_KERNEL);
-        if (mal->tx_virt_addr == NULL) {
+        set_mal_dcrn(mal, MAL_CFG, MAL_CFG_DEFAULT | MAL_CFG_PLBB |
+                     MAL_CFG_OPBBL | MAL_CFG_LEA);
+
+        mal_enable_eob_irq(mal);
+
+        /* Allocate space for BD rings */
+        BUG_ON(maldata->num_tx_chans <= 0 || maldata->num_tx_chans > 32);
+        BUG_ON(maldata->num_rx_chans <= 0 || maldata->num_rx_chans > 32);
+        bd_size = sizeof(struct mal_descriptor) *
+            (NUM_TX_BUFF * maldata->num_tx_chans +
+             NUM_RX_BUFF * maldata->num_rx_chans);
+        mal->bd_virt =
+            dma_alloc_coherent(&ocpdev->dev, bd_size, &mal->bd_dma, GFP_KERNEL);
+
+        if (!mal->bd_virt) {
                 printk(KERN_ERR
-                       "mal%d: Out of memory allocating MAL descriptors !\n",
-                       ocpdev->def->index);
+                       "mal%d: out of memory allocating RX/TX descriptors!\n",
+                       mal->def->index);
                 err = -ENOMEM;
                 goto fail;
         }
+        memset(mal->bd_virt, 0, bd_size);
 
-        /* God, oh, god, I hate DCRs */
-        set_mal_dcrn(mal, DCRN_MALTXCTP0R, mal->tx_phys_addr);
-#ifdef DCRN_MALTXCTP1R
-        if (maldata->num_tx_chans > 1)
-                set_mal_dcrn(mal, DCRN_MALTXCTP1R,
-                             mal->tx_phys_addr + MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP1R */
-#ifdef DCRN_MALTXCTP2R
-        if (maldata->num_tx_chans > 2)
-                set_mal_dcrn(mal, DCRN_MALTXCTP2R,
-                             mal->tx_phys_addr + 2 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP2R */
-#ifdef DCRN_MALTXCTP3R
-        if (maldata->num_tx_chans > 3)
-                set_mal_dcrn(mal, DCRN_MALTXCTP3R,
-                             mal->tx_phys_addr + 3 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP3R */
-#ifdef DCRN_MALTXCTP4R
-        if (maldata->num_tx_chans > 4)
-                set_mal_dcrn(mal, DCRN_MALTXCTP4R,
-                             mal->tx_phys_addr + 4 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP4R */
-#ifdef DCRN_MALTXCTP5R
-        if (maldata->num_tx_chans > 5)
-                set_mal_dcrn(mal, DCRN_MALTXCTP5R,
-                             mal->tx_phys_addr + 5 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP5R */
-#ifdef DCRN_MALTXCTP6R
-        if (maldata->num_tx_chans > 6)
-                set_mal_dcrn(mal, DCRN_MALTXCTP6R,
-                             mal->tx_phys_addr + 6 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP6R */
-#ifdef DCRN_MALTXCTP7R
-        if (maldata->num_tx_chans > 7)
-                set_mal_dcrn(mal, DCRN_MALTXCTP7R,
-                             mal->tx_phys_addr + 7 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALTXCTP7R */
-
-        mal->rx_virt_addr = dma_alloc_coherent(&ocpdev->dev,
-                                               MAL_DT_ALIGN *
-                                               maldata->num_rx_chans,
-                                               &mal->rx_phys_addr, GFP_KERNEL);
-
-        set_mal_dcrn(mal, DCRN_MALRXCTP0R, mal->rx_phys_addr);
-#ifdef DCRN_MALRXCTP1R
-        if (maldata->num_rx_chans > 1)
-                set_mal_dcrn(mal, DCRN_MALRXCTP1R,
-                             mal->rx_phys_addr + MAL_DT_ALIGN);
-#endif                          /* DCRN_MALRXCTP1R */
-#ifdef DCRN_MALRXCTP2R
-        if (maldata->num_rx_chans > 2)
-                set_mal_dcrn(mal, DCRN_MALRXCTP2R,
-                             mal->rx_phys_addr + 2 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALRXCTP2R */
-#ifdef DCRN_MALRXCTP3R
-        if (maldata->num_rx_chans > 3)
-                set_mal_dcrn(mal, DCRN_MALRXCTP3R,
-                             mal->rx_phys_addr + 3 * MAL_DT_ALIGN);
-#endif                          /* DCRN_MALRXCTP3R */
+        for (i = 0; i < maldata->num_tx_chans; ++i)
+                set_mal_dcrn(mal, MAL_TXCTPR(i), mal->bd_dma +
+                             sizeof(struct mal_descriptor) *
+                             mal_tx_bd_offset(mal, i));
+
+        for (i = 0; i < maldata->num_rx_chans; ++i)
+                set_mal_dcrn(mal, MAL_RXCTPR(i), mal->bd_dma +
+                             sizeof(struct mal_descriptor) *
+                             mal_rx_bd_offset(mal, i));
 
         err = request_irq(maldata->serr_irq, mal_serr, 0, "MAL SERR", mal);
         if (err)
-                goto fail;
-        err = request_irq(maldata->txde_irq, mal_txde, 0, "MAL TX DE ", mal);
+                goto fail2;
+        err = request_irq(maldata->txde_irq, mal_txde, 0, "MAL TX DE", mal);
         if (err)
-                goto fail;
+                goto fail3;
         err = request_irq(maldata->txeob_irq, mal_txeob, 0, "MAL TX EOB", mal);
         if (err)
-                goto fail;
+                goto fail4;
         err = request_irq(maldata->rxde_irq, mal_rxde, 0, "MAL RX DE", mal);
         if (err)
-                goto fail;
+                goto fail5;
         err = request_irq(maldata->rxeob_irq, mal_rxeob, 0, "MAL RX EOB", mal);
         if (err)
-                goto fail;
+                goto fail6;
 
-        set_mal_dcrn(mal, DCRN_MALIER,
-                     MALIER_DE | MALIER_NE | MALIER_TE |
-                     MALIER_OPBE | MALIER_PLBE);
+        /* Enable all MAL SERR interrupt sources */
+        set_mal_dcrn(mal, MAL_IER, MAL_IER_EVENTS);
 
-        /* Advertise me to the rest of the world */
+        /* Advertise this instance to the rest of the world */
         ocp_set_drvdata(ocpdev, mal);
 
-        printk(KERN_INFO "mal%d: Initialized, %d tx channels, %d rx channels\n",
-               ocpdev->def->index, maldata->num_tx_chans,
-               maldata->num_rx_chans);
+        mal_dbg_register(mal->def->index, mal);
 
+        printk(KERN_INFO "mal%d: initialized, %d TX channels, %d RX channels\n",
+               mal->def->index, maldata->num_tx_chans, maldata->num_rx_chans);
         return 0;
 
+      fail6:
+        free_irq(maldata->rxde_irq, mal);
+      fail5:
+        free_irq(maldata->txeob_irq, mal);
+      fail4:
+        free_irq(maldata->txde_irq, mal);
+      fail3:
+        free_irq(maldata->serr_irq, mal);
+      fail2:
+        dma_free_coherent(&ocpdev->dev, bd_size, mal->bd_virt, mal->bd_dma);
       fail:
-        /* FIXME: dispose requested IRQs ! */
-        if (err && mal)
-                kfree(mal);
+        kfree(mal);
         return err;
 }
 
 static void __exit mal_remove(struct ocp_device *ocpdev)
 {
         struct ibm_ocp_mal *mal = ocp_get_drvdata(ocpdev);
-        struct ocp_func_mal_data *maldata = ocpdev->def->additions;
+        struct ocp_func_mal_data *maldata = mal->def->additions;
+
+        MAL_DBG("%d: remove" NL, mal->def->index);
 
-        BUG_ON(!maldata);
+        /* Syncronize with scheduled polling, 
+           stolen from net/core/dev.c:dev_close() 
+         */
+        clear_bit(__LINK_STATE_START, &mal->poll_dev.state);
+        netif_poll_disable(&mal->poll_dev);
+
+        if (!list_empty(&mal->list)) {
+                /* This is *very* bad */
+                printk(KERN_EMERG
+                       "mal%d: commac list is not empty on remove!\n",
+                       mal->def->index);
+        }
 
         ocp_set_drvdata(ocpdev, NULL);
 
-        /* FIXME: shut down the MAL, deal with dependency with emac */
         free_irq(maldata->serr_irq, mal);
         free_irq(maldata->txde_irq, mal);
         free_irq(maldata->txeob_irq, mal);
         free_irq(maldata->rxde_irq, mal);
         free_irq(maldata->rxeob_irq, mal);
 
-        if (mal->tx_virt_addr)
-                dma_free_coherent(&ocpdev->dev,
-                                  MAL_DT_ALIGN * maldata->num_tx_chans,
-                                  mal->tx_virt_addr, mal->tx_phys_addr);
+        mal_reset(mal);
 
-        if (mal->rx_virt_addr)
-                dma_free_coherent(&ocpdev->dev,
-                                  MAL_DT_ALIGN * maldata->num_rx_chans,
-                                  mal->rx_virt_addr, mal->rx_phys_addr);
+        mal_dbg_register(mal->def->index, NULL);
+
+        dma_free_coherent(&ocpdev->dev,
+                          sizeof(struct mal_descriptor) *
+                          (NUM_TX_BUFF * maldata->num_tx_chans +
+                           NUM_RX_BUFF * maldata->num_rx_chans), mal->bd_virt,
+                          mal->bd_dma);
 
         kfree(mal);
 }
 
 /* Structure for a device driver */
 static struct ocp_device_id mal_ids[] = {
-        {.vendor = OCP_ANY_ID,.function = OCP_FUNC_MAL},
-        {.vendor = OCP_VENDOR_INVALID}
+        { .vendor = OCP_VENDOR_IBM, .function = OCP_FUNC_MAL },
+        { .vendor = OCP_VENDOR_INVALID}
 };
 
 static struct ocp_driver mal_driver = {
@@ -441,23 +570,14 @@ static struct ocp_driver mal_driver = {
         .remove = mal_remove,
 };
 
-static int __init init_mals(void)
+int __init mal_init(void)
 {
-        int rc;
-
-        rc = ocp_register_driver(&mal_driver);
-        if (rc < 0) {
-                ocp_unregister_driver(&mal_driver);
-                return -ENODEV;
-        }
-
-        return 0;
+        MAL_DBG(": init" NL);
+        return ocp_register_driver(&mal_driver);
 }
 
-static void __exit exit_mals(void)
+void __exit mal_exit(void)
 {
+        MAL_DBG(": exit" NL);
         ocp_unregister_driver(&mal_driver);
 }
-
-module_init(init_mals);
-module_exit(exit_mals);
diff --git a/drivers/net/ibm_emac/ibm_emac_mal.h b/drivers/net/ibm_emac/ibm_emac_mal.h
index dd9f0dabc6e0..15b0bdae26ac 100644
--- a/drivers/net/ibm_emac/ibm_emac_mal.h
+++ b/drivers/net/ibm_emac/ibm_emac_mal.h
@@ -1,131 +1,267 @@
-#ifndef _IBM_EMAC_MAL_H
-#define _IBM_EMAC_MAL_H
+/*
+ * drivers/net/ibm_emac/ibm_emac_mal.h
+ *
+ * Memory Access Layer (MAL) support
+ * 
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2002 MontaVista Softare Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+#ifndef __IBM_EMAC_MAL_H_
+#define __IBM_EMAC_MAL_H_
 
+#include <linux/config.h>
+#include <linux/init.h>
 #include <linux/list.h>
+#include <linux/netdevice.h>
 
-#define MAL_DT_ALIGN    (4096)  /* Alignment for each channel's descriptor table */
+#include <asm/io.h>
 
-#define MAL_CHAN_MASK(chan)     (0x80000000 >> (chan))
+/*
+ * These MAL "versions" probably aren't the real versions IBM uses for these 
+ * MAL cores, I assigned them just to make #ifdefs in this file nicer and 
+ * reflect the fact that 40x and 44x have slightly different MALs. --ebs
+ */
+#if defined(CONFIG_405GP) || defined(CONFIG_405GPR) || defined(CONFIG_405EP) || \
+    defined(CONFIG_440EP) || defined(CONFIG_NP405H)
+#define MAL_VERSION             1
+#elif defined(CONFIG_440GP) || defined(CONFIG_440GX) || defined(CONFIG_440SP)
+#define MAL_VERSION             2
+#else
+#error "Unknown SoC, please check chip manual and choose MAL 'version'"
+#endif
+
+/* MALx DCR registers */
+#define MAL_CFG                 0x00
+#define   MAL_CFG_SR            0x80000000
+#define   MAL_CFG_PLBB          0x00004000
+#define   MAL_CFG_OPBBL         0x00000080
+#define   MAL_CFG_EOPIE         0x00000004
+#define   MAL_CFG_LEA           0x00000002
+#define   MAL_CFG_SD            0x00000001
+#if MAL_VERSION == 1
+#define   MAL_CFG_PLBP_MASK     0x00c00000
+#define   MAL_CFG_PLBP_10       0x00800000
+#define   MAL_CFG_GA            0x00200000
+#define   MAL_CFG_OA            0x00100000
+#define   MAL_CFG_PLBLE         0x00080000
+#define   MAL_CFG_PLBT_MASK     0x00078000
+#define   MAL_CFG_DEFAULT       (MAL_CFG_PLBP_10 | MAL_CFG_PLBT_MASK)
+#elif MAL_VERSION == 2
+#define   MAL_CFG_RPP_MASK      0x00c00000
+#define   MAL_CFG_RPP_10        0x00800000
+#define   MAL_CFG_RMBS_MASK     0x00300000
+#define   MAL_CFG_WPP_MASK      0x000c0000
+#define   MAL_CFG_WPP_10        0x00080000
+#define   MAL_CFG_WMBS_MASK     0x00030000
+#define   MAL_CFG_PLBLE         0x00008000
+#define   MAL_CFG_DEFAULT       (MAL_CFG_RMBS_MASK | MAL_CFG_WMBS_MASK | \
+                                 MAL_CFG_RPP_10 | MAL_CFG_WPP_10)
+#else
+#error "Unknown MAL version"
+#endif
+
+#define MAL_ESR                 0x01
+#define   MAL_ESR_EVB           0x80000000
+#define   MAL_ESR_CIDT          0x40000000
+#define   MAL_ESR_CID_MASK      0x3e000000
+#define   MAL_ESR_CID_SHIFT     25
+#define   MAL_ESR_DE            0x00100000
+#define   MAL_ESR_OTE           0x00040000
+#define   MAL_ESR_OSE           0x00020000
+#define   MAL_ESR_PEIN          0x00010000
+#define   MAL_ESR_DEI           0x00000010
+#define   MAL_ESR_OTEI          0x00000004
+#define   MAL_ESR_OSEI          0x00000002
+#define   MAL_ESR_PBEI          0x00000001
+#if MAL_VERSION == 1
+#define   MAL_ESR_ONE           0x00080000
+#define   MAL_ESR_ONEI          0x00000008
+#elif MAL_VERSION == 2
+#define   MAL_ESR_PTE           0x00800000
+#define   MAL_ESR_PRE           0x00400000
+#define   MAL_ESR_PWE           0x00200000
+#define   MAL_ESR_PTEI          0x00000080
+#define   MAL_ESR_PREI          0x00000040
+#define   MAL_ESR_PWEI          0x00000020
+#else
+#error "Unknown MAL version"
+#endif
+
+#define MAL_IER                 0x02
+#define   MAL_IER_DE            0x00000010
+#define   MAL_IER_OTE           0x00000004
+#define   MAL_IER_OE            0x00000002
+#define   MAL_IER_PE            0x00000001
+#if MAL_VERSION == 1
+#define   MAL_IER_NWE           0x00000008
+#define   MAL_IER_SOC_EVENTS    MAL_IER_NWE
+#elif MAL_VERSION == 2
+#define   MAL_IER_PT            0x00000080
+#define   MAL_IER_PRE           0x00000040
+#define   MAL_IER_PWE           0x00000020
+#define   MAL_IER_SOC_EVENTS    (MAL_IER_PT | MAL_IER_PRE | MAL_IER_PWE)
+#else
+#error "Unknown MAL version"
+#endif
+#define   MAL_IER_EVENTS        (MAL_IER_SOC_EVENTS | MAL_IER_OTE | \
+                                 MAL_IER_OTE | MAL_IER_OE | MAL_IER_PE)
+
+#define MAL_TXCASR              0x04
+#define MAL_TXCARR              0x05
+#define MAL_TXEOBISR            0x06
+#define MAL_TXDEIR              0x07
+#define MAL_RXCASR              0x10
+#define MAL_RXCARR              0x11
+#define MAL_RXEOBISR            0x12
+#define MAL_RXDEIR              0x13
+#define MAL_TXCTPR(n)           ((n) + 0x20)
+#define MAL_RXCTPR(n)           ((n) + 0x40)
+#define MAL_RCBS(n)             ((n) + 0x60)
+
+/* In reality MAL can handle TX buffers up to 4095 bytes long, 
+ * but this isn't a good round number :)                 --ebs
+ */
+#define MAL_MAX_TX_SIZE         4080
+#define MAL_MAX_RX_SIZE         4080
+
+static inline int mal_rx_size(int len)
+{
+        len = (len + 0xf) & ~0xf;
+        return len > MAL_MAX_RX_SIZE ? MAL_MAX_RX_SIZE : len;
+}
+
+static inline int mal_tx_chunks(int len)
+{
+        return (len + MAL_MAX_TX_SIZE - 1) / MAL_MAX_TX_SIZE;
+}
+
+#define MAL_CHAN_MASK(n)        (0x80000000 >> (n))
 
 /* MAL Buffer Descriptor structure */
 struct mal_descriptor {
-        unsigned short ctrl;    /* MAL / Commac status control bits */
-        short data_len;         /* Max length is 4K-1 (12 bits)     */
-        unsigned char *data_ptr;        /* pointer to actual data buffer    */
-} __attribute__ ((packed));
+        u16 ctrl;               /* MAL / Commac status control bits */
+        u16 data_len;           /* Max length is 4K-1 (12 bits)     */
+        u32 data_ptr;           /* pointer to actual data buffer    */
+};
 
 /* the following defines are for the MadMAL status and control registers. */
 /* MADMAL transmit and receive status/control bits  */
-#define MAL_RX_CTRL_EMPTY               0x8000
-#define MAL_RX_CTRL_WRAP                0x4000
-#define MAL_RX_CTRL_CM                  0x2000
-#define MAL_RX_CTRL_LAST                0x1000
-#define MAL_RX_CTRL_FIRST               0x0800
-#define MAL_RX_CTRL_INTR                0x0400
-
-#define MAL_TX_CTRL_READY               0x8000
-#define MAL_TX_CTRL_WRAP                0x4000
-#define MAL_TX_CTRL_CM                  0x2000
-#define MAL_TX_CTRL_LAST                0x1000
-#define MAL_TX_CTRL_INTR                0x0400
+#define MAL_RX_CTRL_EMPTY       0x8000
+#define MAL_RX_CTRL_WRAP        0x4000
+#define MAL_RX_CTRL_CM          0x2000
+#define MAL_RX_CTRL_LAST        0x1000
+#define MAL_RX_CTRL_FIRST       0x0800
+#define MAL_RX_CTRL_INTR        0x0400
+#define MAL_RX_CTRL_SINGLE      (MAL_RX_CTRL_LAST | MAL_RX_CTRL_FIRST)
+#define MAL_IS_SINGLE_RX(ctrl)  (((ctrl) & MAL_RX_CTRL_SINGLE) == MAL_RX_CTRL_SINGLE)
+
+#define MAL_TX_CTRL_READY       0x8000
+#define MAL_TX_CTRL_WRAP        0x4000
+#define MAL_TX_CTRL_CM          0x2000
+#define MAL_TX_CTRL_LAST        0x1000
+#define MAL_TX_CTRL_INTR        0x0400
 
 struct mal_commac_ops {
-        void (*txeob) (void *dev, u32 chanmask);
-        void (*txde) (void *dev, u32 chanmask);
-        void (*rxeob) (void *dev, u32 chanmask);
-        void (*rxde) (void *dev, u32 chanmask);
+        void    (*poll_tx) (void *dev);
+        int     (*poll_rx) (void *dev, int budget);
+        int     (*peek_rx) (void *dev);
+        void    (*rxde) (void *dev);
 };
 
 struct mal_commac {
-        struct mal_commac_ops *ops;
-        void *dev;
-        u32 tx_chan_mask, rx_chan_mask;
-        struct list_head list;
+        struct mal_commac_ops   *ops;
+        void                    *dev;
+        struct list_head        poll_list;
+        int                     rx_stopped;
+
+        u32                     tx_chan_mask;
+        u32                     rx_chan_mask;
+        struct list_head        list;
 };
 
 struct ibm_ocp_mal {
-        int dcrbase;
+        int                     dcrbase;
 
-        struct list_head commac;
-        u32 tx_chan_mask, rx_chan_mask;
+        struct list_head        poll_list;
+        struct net_device       poll_dev;
 
-        dma_addr_t tx_phys_addr;
-        struct mal_descriptor *tx_virt_addr;
+        struct list_head        list;
+        u32                     tx_chan_mask;
+        u32                     rx_chan_mask;
 
-        dma_addr_t rx_phys_addr;
-        struct mal_descriptor *rx_virt_addr;
-};
+        dma_addr_t              bd_dma;
+        struct mal_descriptor   *bd_virt;
 
-#define GET_MAL_STANZA(base,dcrn) \
-        case base: \
-                x = mfdcr(dcrn(base)); \
-                break;
-
-#define SET_MAL_STANZA(base,dcrn, val) \
-        case base: \
-                mtdcr(dcrn(base), (val)); \
-                break;
-
-#define GET_MAL0_STANZA(dcrn) GET_MAL_STANZA(DCRN_MAL_BASE,dcrn)
-#define SET_MAL0_STANZA(dcrn,val) SET_MAL_STANZA(DCRN_MAL_BASE,dcrn,val)
-
-#ifdef DCRN_MAL1_BASE
-#define GET_MAL1_STANZA(dcrn) GET_MAL_STANZA(DCRN_MAL1_BASE,dcrn)
-#define SET_MAL1_STANZA(dcrn,val) SET_MAL_STANZA(DCRN_MAL1_BASE,dcrn,val)
-#else                           /* ! DCRN_MAL1_BASE */
-#define GET_MAL1_STANZA(dcrn)
-#define SET_MAL1_STANZA(dcrn,val)
-#endif
+        struct ocp_def          *def;
+};
 
-#define get_mal_dcrn(mal, dcrn) ({ \
-        u32 x; \
-        switch ((mal)->dcrbase) { \
-                GET_MAL0_STANZA(dcrn) \
-                GET_MAL1_STANZA(dcrn) \
-        default: \
-                x = 0; \
-                BUG(); \
-        } \
-x; })
-
-#define set_mal_dcrn(mal, dcrn, val) do { \
-        switch ((mal)->dcrbase) { \
-                SET_MAL0_STANZA(dcrn,val) \
-                SET_MAL1_STANZA(dcrn,val) \
-        default: \
-                BUG(); \
-        } } while (0)
-
-static inline void mal_enable_tx_channels(struct ibm_ocp_mal *mal, u32 chanmask)
+static inline u32 get_mal_dcrn(struct ibm_ocp_mal *mal, int reg)
 {
-        set_mal_dcrn(mal, DCRN_MALTXCASR,
-                     get_mal_dcrn(mal, DCRN_MALTXCASR) | chanmask);
+        return mfdcr(mal->dcrbase + reg);
 }
 
-static inline void mal_disable_tx_channels(struct ibm_ocp_mal *mal,
-                                           u32 chanmask)
+static inline void set_mal_dcrn(struct ibm_ocp_mal *mal, int reg, u32 val)
 {
-        set_mal_dcrn(mal, DCRN_MALTXCARR, chanmask);
+        mtdcr(mal->dcrbase + reg, val);
 }
 
-static inline void mal_enable_rx_channels(struct ibm_ocp_mal *mal, u32 chanmask)
-{
-        set_mal_dcrn(mal, DCRN_MALRXCASR,
-                     get_mal_dcrn(mal, DCRN_MALRXCASR) | chanmask);
-}
+/* Register MAL devices */
+int mal_init(void) __init;
+void mal_exit(void) __exit;
 
-static inline void mal_disable_rx_channels(struct ibm_ocp_mal *mal,
-                                           u32 chanmask)
-{
-        set_mal_dcrn(mal, DCRN_MALRXCARR, chanmask);
-}
+int mal_register_commac(struct ibm_ocp_mal *mal,
+                        struct mal_commac *commac) __init;
+void mal_unregister_commac(struct ibm_ocp_mal *mal,
+                           struct mal_commac *commac) __exit;
+int mal_set_rcbs(struct ibm_ocp_mal *mal, int channel, unsigned long size);
+
+/* Returns BD ring offset for a particular channel
+   (in 'struct mal_descriptor' elements)
+*/
+int mal_tx_bd_offset(struct ibm_ocp_mal *mal, int channel);
+int mal_rx_bd_offset(struct ibm_ocp_mal *mal, int channel);
+
+void mal_enable_tx_channel(struct ibm_ocp_mal *mal, int channel);
+void mal_disable_tx_channel(struct ibm_ocp_mal *mal, int channel);
+void mal_enable_rx_channel(struct ibm_ocp_mal *mal, int channel);
+void mal_disable_rx_channel(struct ibm_ocp_mal *mal, int channel);
 
-extern int mal_register_commac(struct ibm_ocp_mal *mal,
-                               struct mal_commac *commac);
-extern int mal_unregister_commac(struct ibm_ocp_mal *mal,
-                                 struct mal_commac *commac);
+/* Add/remove EMAC to/from MAL polling list */
+void mal_poll_add(struct ibm_ocp_mal *mal, struct mal_commac *commac);
+void mal_poll_del(struct ibm_ocp_mal *mal, struct mal_commac *commac);
+
+/* Ethtool MAL registers */
+struct ibm_mal_regs {
+        u32 tx_count;
+        u32 rx_count;
+
+        u32 cfg;
+        u32 esr;
+        u32 ier;
+        u32 tx_casr;
+        u32 tx_carr;
+        u32 tx_eobisr;
+        u32 tx_deir;
+        u32 rx_casr;
+        u32 rx_carr;
+        u32 rx_eobisr;
+        u32 rx_deir;
+        u32 tx_ctpr[32];
+        u32 rx_ctpr[32];
+        u32 rcbs[32];
+};
 
-extern int mal_set_rcbs(struct ibm_ocp_mal *mal, int channel,
-                        unsigned long size);
+int mal_get_regs_len(struct ibm_ocp_mal *mal);
+void *mal_dump_regs(struct ibm_ocp_mal *mal, void *buf);
 
-#endif                          /* _IBM_EMAC_MAL_H */
+#endif                          /* __IBM_EMAC_MAL_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_phy.c b/drivers/net/ibm_emac/ibm_emac_phy.c
index 14213f090e91..a27e49cfe43b 100644
--- a/drivers/net/ibm_emac/ibm_emac_phy.c
+++ b/drivers/net/ibm_emac/ibm_emac_phy.c
@@ -1,96 +1,80 @@
 /*
- * ibm_ocp_phy.c
+ * drivers/net/ibm_emac/ibm_emac_phy.c
  *
- * PHY drivers for the ibm ocp ethernet driver. Borrowed
- * from sungem_phy.c, though I only kept the generic MII
+ * Driver for PowerPC 4xx on-chip ethernet controller, PHY support.
+ * Borrowed from sungem_phy.c, though I only kept the generic MII
  * driver for now.
  * 
  * This file should be shared with other drivers or eventually
  * merged as the "low level" part of miilib
  * 
  * (c) 2003, Benjamin Herrenscmidt (benh@kernel.crashing.org)
+ * (c) 2004-2005, Eugene Surovegin <ebs@ebshome.net>
  *
  */
-
 #include <linux/config.h>
-
 #include <linux/module.h>
-
 #include <linux/kernel.h>
-#include <linux/sched.h>
 #include <linux/types.h>
 #include <linux/netdevice.h>
-#include <linux/etherdevice.h>
 #include <linux/mii.h>
 #include <linux/ethtool.h>
 #include <linux/delay.h>
 
+#include <asm/ocp.h>
+
 #include "ibm_emac_phy.h"
 
-static int reset_one_mii_phy(struct mii_phy *phy, int phy_id)
+static inline int phy_read(struct mii_phy *phy, int reg)
+{
+        return phy->mdio_read(phy->dev, phy->address, reg);
+}
+
+static inline void phy_write(struct mii_phy *phy, int reg, int val)
 {
-        u16 val;
+        phy->mdio_write(phy->dev, phy->address, reg, val);
+}
+
+int mii_reset_phy(struct mii_phy *phy)
+{
+        int val;
         int limit = 10000;
 
-        val = __phy_read(phy, phy_id, MII_BMCR);
+        val = phy_read(phy, MII_BMCR);
         val &= ~BMCR_ISOLATE;
         val |= BMCR_RESET;
-        __phy_write(phy, phy_id, MII_BMCR, val);
+        phy_write(phy, MII_BMCR, val);
 
-        udelay(100);
+        udelay(300);
 
         while (limit--) {
-                val = __phy_read(phy, phy_id, MII_BMCR);
-                if ((val & BMCR_RESET) == 0)
+                val = phy_read(phy, MII_BMCR);
+                if (val >= 0 && (val & BMCR_RESET) == 0)
                         break;
                 udelay(10);
         }
         if ((val & BMCR_ISOLATE) && limit > 0)
-                __phy_write(phy, phy_id, MII_BMCR, val & ~BMCR_ISOLATE);
-
-        return (limit <= 0);
-}
-
-static int cis8201_init(struct mii_phy *phy)
-{
-        u16 epcr;
-
-        epcr = phy_read(phy, MII_CIS8201_EPCR);
-        epcr &= ~EPCR_MODE_MASK;
-
-        switch (phy->mode) {
-        case PHY_MODE_TBI:
-                epcr |= EPCR_TBI_MODE;
-                break;
-        case PHY_MODE_RTBI:
-                epcr |= EPCR_RTBI_MODE;
-                break;
-        case PHY_MODE_GMII:
-                epcr |= EPCR_GMII_MODE;
-                break;
-        case PHY_MODE_RGMII:
-        default:
-                epcr |= EPCR_RGMII_MODE;
-        }
+                phy_write(phy, MII_BMCR, val & ~BMCR_ISOLATE);
 
-        phy_write(phy, MII_CIS8201_EPCR, epcr);
-
-        return 0;
+        return limit <= 0;
 }
 
 static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
 {
-        u16 ctl, adv;
+        int ctl, adv;
 
-        phy->autoneg = 1;
+        phy->autoneg = AUTONEG_ENABLE;
         phy->speed = SPEED_10;
         phy->duplex = DUPLEX_HALF;
-        phy->pause = 0;
+        phy->pause = phy->asym_pause = 0;
         phy->advertising = advertise;
 
         /* Setup standard advertise */
         adv = phy_read(phy, MII_ADVERTISE);
-        adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
+        if (adv < 0)
+                return adv;
+        adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
+                 ADVERTISE_PAUSE_ASYM);
         if (advertise & ADVERTISED_10baseT_Half)
                 adv |= ADVERTISE_10HALF;
         if (advertise & ADVERTISED_10baseT_Full)
@@ -99,8 +83,25 @@ static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
                 adv |= ADVERTISE_100HALF;
         if (advertise & ADVERTISED_100baseT_Full)
                 adv |= ADVERTISE_100FULL;
+        if (advertise & ADVERTISED_Pause)
+                adv |= ADVERTISE_PAUSE_CAP;
+        if (advertise & ADVERTISED_Asym_Pause)
+                adv |= ADVERTISE_PAUSE_ASYM;
         phy_write(phy, MII_ADVERTISE, adv);
 
+        if (phy->features &
+            (SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half)) {
+                adv = phy_read(phy, MII_CTRL1000);
+                if (adv < 0)
+                        return adv;
+                adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
+                if (advertise & ADVERTISED_1000baseT_Full)
+                        adv |= ADVERTISE_1000FULL;
+                if (advertise & ADVERTISED_1000baseT_Half)
+                        adv |= ADVERTISE_1000HALF;
+                phy_write(phy, MII_CTRL1000, adv);
+        }
+
         /* Start/Restart aneg */
         ctl = phy_read(phy, MII_BMCR);
         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
@@ -111,14 +112,16 @@ static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise)
 
 static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
 {
-        u16 ctl;
+        int ctl;
 
-        phy->autoneg = 0;
+        phy->autoneg = AUTONEG_DISABLE;
         phy->speed = speed;
         phy->duplex = fd;
-        phy->pause = 0;
+        phy->pause = phy->asym_pause = 0;
 
         ctl = phy_read(phy, MII_BMCR);
+        if (ctl < 0)
+                return ctl;
         ctl &= ~(BMCR_FULLDPLX | BMCR_SPEED100 | BMCR_ANENABLE);
 
         /* First reset the PHY */
@@ -132,6 +135,8 @@ static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
                 ctl |= BMCR_SPEED100;
                 break;
         case SPEED_1000:
+                ctl |= BMCR_SPEED1000;
+                break;
         default:
                 return -EINVAL;
         }
@@ -144,112 +149,143 @@ static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd)
 
 static int genmii_poll_link(struct mii_phy *phy)
 {
-        u16 status;
+        int status;
 
-        (void)phy_read(phy, MII_BMSR);
+        /* Clear latched value with dummy read */
+        phy_read(phy, MII_BMSR);
         status = phy_read(phy, MII_BMSR);
-        if ((status & BMSR_LSTATUS) == 0)
+        if (status < 0 || (status & BMSR_LSTATUS) == 0)
                 return 0;
-        if (phy->autoneg && !(status & BMSR_ANEGCOMPLETE))
+        if (phy->autoneg == AUTONEG_ENABLE && !(status & BMSR_ANEGCOMPLETE))
                 return 0;
         return 1;
 }
 
-#define MII_CIS8201_ACSR        0x1c
-#define  ACSR_DUPLEX_STATUS     0x0020
-#define  ACSR_SPEED_1000BASET   0x0010
-#define  ACSR_SPEED_100BASET    0x0008
-
-static int cis8201_read_link(struct mii_phy *phy)
+static int genmii_read_link(struct mii_phy *phy)
 {
-        u16 acsr;
+        if (phy->autoneg == AUTONEG_ENABLE) {
+                int glpa = 0;
+                int lpa = phy_read(phy, MII_LPA) & phy_read(phy, MII_ADVERTISE);
+                if (lpa < 0)
+                        return lpa;
+
+                if (phy->features &
+                    (SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half)) {
+                        int adv = phy_read(phy, MII_CTRL1000);
+                        glpa = phy_read(phy, MII_STAT1000);
+
+                        if (glpa < 0 || adv < 0)
+                                return adv;
+
+                        glpa &= adv << 2;
+                }
+
+                phy->speed = SPEED_10;
+                phy->duplex = DUPLEX_HALF;
+                phy->pause = phy->asym_pause = 0;
+
+                if (glpa & (LPA_1000FULL | LPA_1000HALF)) {
+                        phy->speed = SPEED_1000;
+                        if (glpa & LPA_1000FULL)
+                                phy->duplex = DUPLEX_FULL;
+                } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
+                        phy->speed = SPEED_100;
+                        if (lpa & LPA_100FULL)
+                                phy->duplex = DUPLEX_FULL;
+                } else if (lpa & LPA_10FULL)
+                        phy->duplex = DUPLEX_FULL;
 
-        if (phy->autoneg) {
-                acsr = phy_read(phy, MII_CIS8201_ACSR);
+                if (phy->duplex == DUPLEX_FULL) {
+                        phy->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
+                        phy->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
+                }
+        } else {
+                int bmcr = phy_read(phy, MII_BMCR);
+                if (bmcr < 0)
+                        return bmcr;
 
-                if (acsr & ACSR_DUPLEX_STATUS)
+                if (bmcr & BMCR_FULLDPLX)
                         phy->duplex = DUPLEX_FULL;
                 else
                         phy->duplex = DUPLEX_HALF;
-                if (acsr & ACSR_SPEED_1000BASET) {
+                if (bmcr & BMCR_SPEED1000)
                         phy->speed = SPEED_1000;
-                } else if (acsr & ACSR_SPEED_100BASET)
+                else if (bmcr & BMCR_SPEED100)
                         phy->speed = SPEED_100;
                 else
                         phy->speed = SPEED_10;
-                phy->pause = 0;
-        }
-        /* On non-aneg, we assume what we put in BMCR is the speed,
-         * though magic-aneg shouldn't prevent this case from occurring
-         */
 
+                phy->pause = phy->asym_pause = 0;
+        }
         return 0;
 }
 
-static int genmii_read_link(struct mii_phy *phy)
+/* Generic implementation for most 10/100/1000 PHYs */
+static struct mii_phy_ops generic_phy_ops = {
+        .setup_aneg     = genmii_setup_aneg,
+        .setup_forced   = genmii_setup_forced,
+        .poll_link      = genmii_poll_link,
+        .read_link      = genmii_read_link
+};
+
+static struct mii_phy_def genmii_phy_def = {
+        .phy_id         = 0x00000000,
+        .phy_id_mask    = 0x00000000,
+        .name           = "Generic MII",
+        .ops            = &generic_phy_ops
+};
+
+/* CIS8201 */
+#define MII_CIS8201_EPCR        0x17
+#define  EPCR_MODE_MASK         0x3000
+#define  EPCR_GMII_MODE         0x0000
+#define  EPCR_RGMII_MODE        0x1000
+#define  EPCR_TBI_MODE          0x2000
+#define  EPCR_RTBI_MODE         0x3000
+
+static int cis8201_init(struct mii_phy *phy)
 {
-        u16 lpa;
+        int epcr;
 
-        if (phy->autoneg) {
-                lpa = phy_read(phy, MII_LPA) & phy_read(phy, MII_ADVERTISE);
+        epcr = phy_read(phy, MII_CIS8201_EPCR);
+        if (epcr < 0)
+                return epcr;
 
-                phy->speed = SPEED_10;
-                phy->duplex = DUPLEX_HALF;
-                phy->pause = 0;
+        epcr &= ~EPCR_MODE_MASK;
 
-                if (lpa & (LPA_100FULL | LPA_100HALF)) {
-                        phy->speed = SPEED_100;
-                        if (lpa & LPA_100FULL)
-                                phy->duplex = DUPLEX_FULL;
-                } else if (lpa & LPA_10FULL)
-                        phy->duplex = DUPLEX_FULL;
+        switch (phy->mode) {
+        case PHY_MODE_TBI:
+                epcr |= EPCR_TBI_MODE;
+                break;
+        case PHY_MODE_RTBI:
+                epcr |= EPCR_RTBI_MODE;
+                break;
+        case PHY_MODE_GMII:
+                epcr |= EPCR_GMII_MODE;
+                break;
+        case PHY_MODE_RGMII:
+        default:
+                epcr |= EPCR_RGMII_MODE;
         }
-        /* On non-aneg, we assume what we put in BMCR is the speed,
-         * though magic-aneg shouldn't prevent this case from occurring
-         */
+
+        phy_write(phy, MII_CIS8201_EPCR, epcr);
 
         return 0;
 }
 
-#define MII_BASIC_FEATURES      (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | \
-                                 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | \
-                                 SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII)
-#define MII_GBIT_FEATURES       (MII_BASIC_FEATURES | \
-                                 SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full)
-
-/* CIS8201 phy ops */
 static struct mii_phy_ops cis8201_phy_ops = {
-        init:cis8201_init,
-        setup_aneg:genmii_setup_aneg,
-        setup_forced:genmii_setup_forced,
-        poll_link:genmii_poll_link,
-        read_link:cis8201_read_link
-};
-
-/* Generic implementation for most 10/100 PHYs */
-static struct mii_phy_ops generic_phy_ops = {
-        setup_aneg:genmii_setup_aneg,
-        setup_forced:genmii_setup_forced,
-        poll_link:genmii_poll_link,
-        read_link:genmii_read_link
+        .init           = cis8201_init,
+        .setup_aneg     = genmii_setup_aneg,
+        .setup_forced   = genmii_setup_forced,
+        .poll_link      = genmii_poll_link,
+        .read_link      = genmii_read_link
 };
 
 static struct mii_phy_def cis8201_phy_def = {
-        phy_id:0x000fc410,
-        phy_id_mask:0x000ffff0,
-        name:"CIS8201 Gigabit Ethernet",
-        features:MII_GBIT_FEATURES,
-        magic_aneg:0,
-        ops:&cis8201_phy_ops
-};
-
-static struct mii_phy_def genmii_phy_def = {
-        phy_id:0x00000000,
-        phy_id_mask:0x00000000,
-        name:"Generic MII",
-        features:MII_BASIC_FEATURES,
-        magic_aneg:0,
-        ops:&generic_phy_ops
+        .phy_id         = 0x000fc410,
+        .phy_id_mask    = 0x000ffff0,
+        .name           = "CIS8201 Gigabit Ethernet",
+        .ops            = &cis8201_phy_ops
 };
 
 static struct mii_phy_def *mii_phy_table[] = {
@@ -258,39 +294,60 @@ static struct mii_phy_def *mii_phy_table[] = {
         NULL
 };
 
-int mii_phy_probe(struct mii_phy *phy, int mii_id)
+int mii_phy_probe(struct mii_phy *phy, int address)
 {
-        int rc;
-        u32 id;
         struct mii_phy_def *def;
         int i;
+        u32 id;
 
-        phy->autoneg = 0;
+        phy->autoneg = AUTONEG_DISABLE;
         phy->advertising = 0;
-        phy->mii_id = mii_id;
-        phy->speed = 0;
-        phy->duplex = 0;
-        phy->pause = 0;
-
-        /* Take PHY out of isloate mode and reset it. */
-        rc = reset_one_mii_phy(phy, mii_id);
-        if (rc)
+        phy->address = address;
+        phy->speed = SPEED_10;
+        phy->duplex = DUPLEX_HALF;
+        phy->pause = phy->asym_pause = 0;
+
+        /* Take PHY out of isolate mode and reset it. */
+        if (mii_reset_phy(phy))
                 return -ENODEV;
 
         /* Read ID and find matching entry */
-        id = (phy_read(phy, MII_PHYSID1) << 16 | phy_read(phy, MII_PHYSID2))
-            & 0xfffffff0;
+        id = (phy_read(phy, MII_PHYSID1) << 16) | phy_read(phy, MII_PHYSID2);
         for (i = 0; (def = mii_phy_table[i]) != NULL; i++)
                 if ((id & def->phy_id_mask) == def->phy_id)
                         break;
         /* Should never be NULL (we have a generic entry), but... */
-        if (def == NULL)
+        if (!def)
                 return -ENODEV;
 
         phy->def = def;
 
+        /* Determine PHY features if needed */
+        phy->features = def->features;
+        if (!phy->features) {
+                u16 bmsr = phy_read(phy, MII_BMSR);
+                if (bmsr & BMSR_ANEGCAPABLE)
+                        phy->features |= SUPPORTED_Autoneg;
+                if (bmsr & BMSR_10HALF)
+                        phy->features |= SUPPORTED_10baseT_Half;
+                if (bmsr & BMSR_10FULL)
+                        phy->features |= SUPPORTED_10baseT_Full;
+                if (bmsr & BMSR_100HALF)
+                        phy->features |= SUPPORTED_100baseT_Half;
+                if (bmsr & BMSR_100FULL)
+                        phy->features |= SUPPORTED_100baseT_Full;
+                if (bmsr & BMSR_ESTATEN) {
+                        u16 esr = phy_read(phy, MII_ESTATUS);
+                        if (esr & ESTATUS_1000_TFULL)
+                                phy->features |= SUPPORTED_1000baseT_Full;
+                        if (esr & ESTATUS_1000_THALF)
+                                phy->features |= SUPPORTED_1000baseT_Half;
+                }
+                phy->features |= SUPPORTED_MII;
+        }
+
         /* Setup default advertising */
-        phy->advertising = def->features;
+        phy->advertising = phy->features;
 
         return 0;
 }
diff --git a/drivers/net/ibm_emac/ibm_emac_phy.h b/drivers/net/ibm_emac/ibm_emac_phy.h
index 61afbea96563..a70e0fea54c4 100644
--- a/drivers/net/ibm_emac/ibm_emac_phy.h
+++ b/drivers/net/ibm_emac/ibm_emac_phy.h
@@ -1,65 +1,25 @@
-
 /*
- * ibm_emac_phy.h
- *
+ * drivers/net/ibm_emac/ibm_emac_phy.h
  *
- *      Benjamin Herrenschmidt <benh@kernel.crashing.org>
- *      February 2003
+ * Driver for PowerPC 4xx on-chip ethernet controller, PHY support
  *
- * 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.
+ * Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ * February 2003
  *
- *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR   IMPLIED
- *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
- *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
- *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT,  INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
- *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *  You should have received a copy of the  GNU General Public License along
- *  with this program; if not, write  to the Free Software Foundation, Inc.,
- *  675 Mass Ave, Cambridge, MA 02139, USA.
+ * Minor additions by Eugene Surovegin <ebs@ebshome.net>, 2004
  *
+ * 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 file basically duplicates sungem_phy.{c,h} with different PHYs
  * supported. I'm looking into merging that in a single mii layer more
  * flexible than mii.c 
  */
 
-#ifndef _IBM_EMAC_PHY_H_
-#define _IBM_EMAC_PHY_H_
-
-/*
- * PHY mode settings
- * Used for multi-mode capable PHYs
- */
-#define PHY_MODE_NA     0
-#define PHY_MODE_MII    1
-#define PHY_MODE_RMII   2
-#define PHY_MODE_SMII   3
-#define PHY_MODE_RGMII  4
-#define PHY_MODE_TBI    5
-#define PHY_MODE_GMII   6
-#define PHY_MODE_RTBI   7
-#define PHY_MODE_SGMII  8
-
-/*
- * PHY specific registers/values
- */
-
-/* CIS8201 */
-#define MII_CIS8201_EPCR        0x17
-#define EPCR_MODE_MASK          0x3000
-#define EPCR_GMII_MODE          0x0000
-#define EPCR_RGMII_MODE         0x1000
-#define EPCR_TBI_MODE           0x2000
-#define EPCR_RTBI_MODE          0x3000
+#ifndef _IBM_OCP_PHY_H_
+#define _IBM_OCP_PHY_H_
 
 struct mii_phy;
 
@@ -77,7 +37,8 @@ struct mii_phy_ops {
 struct mii_phy_def {
         u32 phy_id;             /* Concatenated ID1 << 16 | ID2 */
         u32 phy_id_mask;        /* Significant bits */
-        u32 features;           /* Ethtool SUPPORTED_* defines */
+        u32 features;           /* Ethtool SUPPORTED_* defines or 
+                                   0 for autodetect */
         int magic_aneg;         /* Autoneg does all speed test for us */
         const char *name;
         const struct mii_phy_ops *ops;
@@ -86,8 +47,11 @@ struct mii_phy_def {
 /* An instance of a PHY, partially borrowed from mii_if_info */
 struct mii_phy {
         struct mii_phy_def *def;
-        int advertising;
-        int mii_id;
+        u32 advertising;        /* Ethtool ADVERTISED_* defines */
+        u32 features;           /* Copied from mii_phy_def.features 
+                                   or determined automaticaly */
+        int address;            /* PHY address */
+        int mode;               /* PHY mode */
 
         /* 1: autoneg enabled, 0: disabled */
         int autoneg;
@@ -98,40 +62,19 @@ struct mii_phy {
         int speed;
         int duplex;
         int pause;
-
-        /* PHY mode - if needed */
-        int mode;
+        int asym_pause;
 
         /* Provided by host chip */
         struct net_device *dev;
-        int (*mdio_read) (struct net_device * dev, int mii_id, int reg);
-        void (*mdio_write) (struct net_device * dev, int mii_id, int reg,
+        int (*mdio_read) (struct net_device * dev, int addr, int reg);
+        void (*mdio_write) (struct net_device * dev, int addr, int reg,
                             int val);
 };
 
 /* Pass in a struct mii_phy with dev, mdio_read and mdio_write
  * filled, the remaining fields will be filled on return
  */
-extern int mii_phy_probe(struct mii_phy *phy, int mii_id);
-
-static inline int __phy_read(struct mii_phy *phy, int id, int reg)
-{
-        return phy->mdio_read(phy->dev, id, reg);
-}
-
-static inline void __phy_write(struct mii_phy *phy, int id, int reg, int val)
-{
-        phy->mdio_write(phy->dev, id, reg, val);
-}
-
-static inline int phy_read(struct mii_phy *phy, int reg)
-{
-        return phy->mdio_read(phy->dev, phy->mii_id, reg);
-}
-
-static inline void phy_write(struct mii_phy *phy, int reg, int val)
-{
-        phy->mdio_write(phy->dev, phy->mii_id, reg, val);
-}
+int mii_phy_probe(struct mii_phy *phy, int address);
+int mii_reset_phy(struct mii_phy *phy);
 
-#endif                          /* _IBM_EMAC_PHY_H_ */
+#endif                          /* _IBM_OCP_PHY_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_rgmii.c b/drivers/net/ibm_emac/ibm_emac_rgmii.c
new file mode 100644
index 000000000000..f0b1ffb2dbbf
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_rgmii.c
@@ -0,0 +1,201 @@
+/*
+ * drivers/net/ibm_emac/ibm_emac_rgmii.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, RGMII bridge support.
+ *
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * Based on original work by
+ *      Matt Porter <mporter@kernel.crashing.org>
+ *      Copyright 2004 MontaVista Software, Inc.
+ * 
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/ethtool.h>
+#include <asm/io.h>
+
+#include "ibm_emac_core.h"
+#include "ibm_emac_debug.h"
+
+/* RGMIIx_FER */
+#define RGMII_FER_MASK(idx)     (0x7 << ((idx) * 4))
+#define RGMII_FER_RTBI(idx)     (0x4 << ((idx) * 4))
+#define RGMII_FER_RGMII(idx)    (0x5 << ((idx) * 4))
+#define RGMII_FER_TBI(idx)      (0x6 << ((idx) * 4))
+#define RGMII_FER_GMII(idx)     (0x7 << ((idx) * 4))
+
+/* RGMIIx_SSR */
+#define RGMII_SSR_MASK(idx)     (0x7 << ((idx) * 8))
+#define RGMII_SSR_100(idx)      (0x2 << ((idx) * 8))
+#define RGMII_SSR_1000(idx)     (0x4 << ((idx) * 8))
+
+/* RGMII bridge supports only GMII/TBI and RGMII/RTBI PHYs */
+static inline int rgmii_valid_mode(int phy_mode)
+{
+        return  phy_mode == PHY_MODE_GMII ||
+                phy_mode == PHY_MODE_RGMII ||
+                phy_mode == PHY_MODE_TBI ||
+                phy_mode == PHY_MODE_RTBI;
+}
+
+static inline const char *rgmii_mode_name(int mode)
+{
+        switch (mode) {
+        case PHY_MODE_RGMII:
+                return "RGMII";
+        case PHY_MODE_TBI:
+                return "TBI";
+        case PHY_MODE_GMII:
+                return "GMII";
+        case PHY_MODE_RTBI:
+                return "RTBI";
+        default:
+                BUG();
+        }
+}
+
+static inline u32 rgmii_mode_mask(int mode, int input)
+{
+        switch (mode) {
+        case PHY_MODE_RGMII:
+                return RGMII_FER_RGMII(input);
+        case PHY_MODE_TBI:
+                return RGMII_FER_TBI(input);
+        case PHY_MODE_GMII:
+                return RGMII_FER_GMII(input);
+        case PHY_MODE_RTBI:
+                return RGMII_FER_RTBI(input);
+        default:
+                BUG();
+        }
+}
+
+static int __init rgmii_init(struct ocp_device *ocpdev, int input, int mode)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        struct rgmii_regs *p;
+
+        RGMII_DBG("%d: init(%d, %d)" NL, ocpdev->def->index, input, mode);
+
+        if (!dev) {
+                dev = kzalloc(sizeof(struct ibm_ocp_rgmii), GFP_KERNEL);
+                if (!dev) {
+                        printk(KERN_ERR
+                               "rgmii%d: couldn't allocate device structure!\n",
+                               ocpdev->def->index);
+                        return -ENOMEM;
+                }
+
+                p = (struct rgmii_regs *)ioremap(ocpdev->def->paddr,
+                                                 sizeof(struct rgmii_regs));
+                if (!p) {
+                        printk(KERN_ERR
+                               "rgmii%d: could not ioremap device registers!\n",
+                               ocpdev->def->index);
+                        kfree(dev);
+                        return -ENOMEM;
+                }
+
+                dev->base = p;
+                ocp_set_drvdata(ocpdev, dev);
+
+                /* Disable all inputs by default */
+                out_be32(&p->fer, 0);
+        } else
+                p = dev->base;
+
+        /* Enable this input */
+        out_be32(&p->fer, in_be32(&p->fer) | rgmii_mode_mask(mode, input));
+
+        printk(KERN_NOTICE "rgmii%d: input %d in %s mode\n",
+               ocpdev->def->index, input, rgmii_mode_name(mode));
+
+        ++dev->users;
+        return 0;
+}
+
+int __init rgmii_attach(void *emac)
+{
+        struct ocp_enet_private *dev = emac;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+
+        /* Check if we need to attach to a RGMII */
+        if (emacdata->rgmii_idx >= 0 && rgmii_valid_mode(emacdata->phy_mode)) {
+                dev->rgmii_input = emacdata->rgmii_mux;
+                dev->rgmii_dev =
+                    ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_RGMII,
+                                    emacdata->rgmii_idx);
+                if (!dev->rgmii_dev) {
+                        printk(KERN_ERR "emac%d: unknown rgmii%d!\n",
+                               dev->def->index, emacdata->rgmii_idx);
+                        return -ENODEV;
+                }
+                if (rgmii_init
+                    (dev->rgmii_dev, dev->rgmii_input, emacdata->phy_mode)) {
+                        printk(KERN_ERR
+                               "emac%d: rgmii%d initialization failed!\n",
+                               dev->def->index, emacdata->rgmii_idx);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+void rgmii_set_speed(struct ocp_device *ocpdev, int input, int speed)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        u32 ssr = in_be32(&dev->base->ssr) & ~RGMII_SSR_MASK(input);
+
+        RGMII_DBG("%d: speed(%d, %d)" NL, ocpdev->def->index, input, speed);
+
+        if (speed == SPEED_1000)
+                ssr |= RGMII_SSR_1000(input);
+        else if (speed == SPEED_100)
+                ssr |= RGMII_SSR_100(input);
+
+        out_be32(&dev->base->ssr, ssr);
+}
+
+void __exit __rgmii_fini(struct ocp_device *ocpdev, int input)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        BUG_ON(!dev || dev->users == 0);
+
+        RGMII_DBG("%d: fini(%d)" NL, ocpdev->def->index, input);
+
+        /* Disable this input */
+        out_be32(&dev->base->fer,
+                 in_be32(&dev->base->fer) & ~RGMII_FER_MASK(input));
+
+        if (!--dev->users) {
+                /* Free everything if this is the last user */
+                ocp_set_drvdata(ocpdev, NULL);
+                iounmap((void *)dev->base);
+                kfree(dev);
+        }
+}
+
+int __rgmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct rgmii_regs);
+}
+
+void *rgmii_dump_regs(struct ocp_device *ocpdev, void *buf)
+{
+        struct ibm_ocp_rgmii *dev = ocp_get_drvdata(ocpdev);
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct rgmii_regs *regs = (struct rgmii_regs *)(hdr + 1);
+
+        hdr->version = 0;
+        hdr->index = ocpdev->def->index;
+        memcpy_fromio(regs, dev->base, sizeof(struct rgmii_regs));
+        return regs + 1;
+}
diff --git a/drivers/net/ibm_emac/ibm_emac_rgmii.h b/drivers/net/ibm_emac/ibm_emac_rgmii.h
index 49f188f4ea6e..a1ffb8a44fff 100644
--- a/drivers/net/ibm_emac/ibm_emac_rgmii.h
+++ b/drivers/net/ibm_emac/ibm_emac_rgmii.h
@@ -1,5 +1,7 @@
 /*
- * Defines for the IBM RGMII bridge
+ * drivers/net/ibm_emac/ibm_emac_rgmii.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, RGMII bridge support.
  *
  * Based on ocp_zmii.h/ibm_emac_zmii.h
  * Armin Kuster akuster@mvista.com
@@ -7,6 +9,9 @@
  * Copyright 2004 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
  * 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
@@ -19,47 +24,42 @@
 #include <linux/config.h>
 
 /* RGMII bridge */
-typedef struct rgmii_regs {
+struct rgmii_regs {
         u32 fer;                /* Function enable register */
         u32 ssr;                /* Speed select register */
-} rgmii_t;
-
-#define RGMII_INPUTS                    4
+};
 
 /* RGMII device */
 struct ibm_ocp_rgmii {
         struct rgmii_regs *base;
-        int mode[RGMII_INPUTS];
         int users;              /* number of EMACs using this RGMII bridge */
 };
 
-/* Fuctional Enable Reg */
-#define RGMII_FER_MASK(x)               (0x00000007 << (4*x))
-#define RGMII_RTBI                      0x00000004
-#define RGMII_RGMII                     0x00000005
-#define RGMII_TBI                       0x00000006
-#define RGMII_GMII                      0x00000007
-
-/* Speed Selection reg */
+#ifdef CONFIG_IBM_EMAC_RGMII
+int rgmii_attach(void *emac) __init;
 
-#define RGMII_SP2_100   0x00000002
-#define RGMII_SP2_1000  0x00000004
-#define RGMII_SP3_100   0x00000200
-#define RGMII_SP3_1000  0x00000400
+void __rgmii_fini(struct ocp_device *ocpdev, int input) __exit;
+static inline void rgmii_fini(struct ocp_device *ocpdev, int input)
+{
+        if (ocpdev)
+                __rgmii_fini(ocpdev, input);
+}
 
-#define RGMII_MII2_SPDMASK       0x00000007
-#define RGMII_MII3_SPDMASK       0x00000700
+void rgmii_set_speed(struct ocp_device *ocpdev, int input, int speed);
 
-#define RGMII_MII2_100MB         RGMII_SP2_100 & ~RGMII_SP2_1000
-#define RGMII_MII2_1000MB        RGMII_SP2_1000 & ~RGMII_SP2_100
-#define RGMII_MII2_10MB          ~(RGMII_SP2_100 | RGMII_SP2_1000)
-#define RGMII_MII3_100MB         RGMII_SP3_100 & ~RGMII_SP3_1000
-#define RGMII_MII3_1000MB        RGMII_SP3_1000 & ~RGMII_SP3_100
-#define RGMII_MII3_10MB          ~(RGMII_SP3_100 | RGMII_SP3_1000)
+int __rgmii_get_regs_len(struct ocp_device *ocpdev);
+static inline int rgmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return ocpdev ? __rgmii_get_regs_len(ocpdev) : 0;
+}
 
-#define RTBI            0
-#define RGMII           1
-#define TBI             2
-#define GMII            3
+void *rgmii_dump_regs(struct ocp_device *ocpdev, void *buf);
+#else
+# define rgmii_attach(x)        0
+# define rgmii_fini(x,y)        ((void)0)
+# define rgmii_set_speed(x,y,z) ((void)0)
+# define rgmii_get_regs_len(x)  0
+# define rgmii_dump_regs(x,buf) (buf)
+#endif                          /* !CONFIG_IBM_EMAC_RGMII */
 
 #endif                          /* _IBM_EMAC_RGMII_H_ */
diff --git a/drivers/net/ibm_emac/ibm_emac_tah.c b/drivers/net/ibm_emac/ibm_emac_tah.c
new file mode 100644
index 000000000000..af08afc22f9f
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_tah.c
@@ -0,0 +1,111 @@
+/*
+ * drivers/net/ibm_emac/ibm_emac_tah.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, TAH support.
+ *
+ * Copyright 2004 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * Copyright (c) 2005 Eugene Surovegin <ebs@ebshome.net>
+ *
+ * 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/config.h>
+#include <asm/io.h>
+
+#include "ibm_emac_core.h"
+
+static int __init tah_init(struct ocp_device *ocpdev)
+{
+        struct tah_regs *p;
+
+        if (ocp_get_drvdata(ocpdev)) {
+                printk(KERN_ERR "tah%d: already in use!\n", ocpdev->def->index);
+                return -EBUSY;
+        }
+
+        /* Initialize TAH and enable IPv4 checksum verification, no TSO yet */
+        p = (struct tah_regs *)ioremap(ocpdev->def->paddr, sizeof(*p));
+        if (!p) {
+                printk(KERN_ERR "tah%d: could not ioremap device registers!\n",
+                       ocpdev->def->index);
+                return -ENOMEM;
+        }
+        ocp_set_drvdata(ocpdev, p);
+        __tah_reset(ocpdev);
+
+        return 0;
+}
+
+int __init tah_attach(void *emac)
+{
+        struct ocp_enet_private *dev = emac;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+
+        /* Check if we need to attach to a TAH */
+        if (emacdata->tah_idx >= 0) {
+                dev->tah_dev = ocp_find_device(OCP_ANY_ID, OCP_FUNC_TAH,
+                                               emacdata->tah_idx);
+                if (!dev->tah_dev) {
+                        printk(KERN_ERR "emac%d: unknown tah%d!\n",
+                               dev->def->index, emacdata->tah_idx);
+                        return -ENODEV;
+                }
+                if (tah_init(dev->tah_dev)) {
+                        printk(KERN_ERR
+                               "emac%d: tah%d initialization failed!\n",
+                               dev->def->index, emacdata->tah_idx);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+void __exit __tah_fini(struct ocp_device *ocpdev)
+{
+        struct tah_regs *p = ocp_get_drvdata(ocpdev);
+        BUG_ON(!p);
+        ocp_set_drvdata(ocpdev, NULL);
+        iounmap((void *)p);
+}
+
+void __tah_reset(struct ocp_device *ocpdev)
+{
+        struct tah_regs *p = ocp_get_drvdata(ocpdev);
+        int n;
+
+        /* Reset TAH */
+        out_be32(&p->mr, TAH_MR_SR);
+        n = 100;
+        while ((in_be32(&p->mr) & TAH_MR_SR) && n)
+                --n;
+
+        if (unlikely(!n))
+                printk(KERN_ERR "tah%d: reset timeout\n", ocpdev->def->index);
+
+        /* 10KB TAH TX FIFO accomodates the max MTU of 9000 */
+        out_be32(&p->mr,
+                 TAH_MR_CVR | TAH_MR_ST_768 | TAH_MR_TFS_10KB | TAH_MR_DTFP |
+                 TAH_MR_DIG);
+}
+
+int __tah_get_regs_len(struct ocp_device *ocpdev)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct tah_regs);
+}
+
+void *tah_dump_regs(struct ocp_device *ocpdev, void *buf)
+{
+        struct tah_regs *dev = ocp_get_drvdata(ocpdev);
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct tah_regs *regs = (struct tah_regs *)(hdr + 1);
+
+        hdr->version = 0;
+        hdr->index = ocpdev->def->index;
+        memcpy_fromio(regs, dev, sizeof(struct tah_regs));
+        return regs + 1;
+}
diff --git a/drivers/net/ibm_emac/ibm_emac_tah.h b/drivers/net/ibm_emac/ibm_emac_tah.h
index ecfc69805521..9299b5dd7eb1 100644
--- a/drivers/net/ibm_emac/ibm_emac_tah.h
+++ b/drivers/net/ibm_emac/ibm_emac_tah.h
@@ -1,9 +1,13 @@
 /*
- * Defines for the IBM TAH
+ * drivers/net/ibm_emac/ibm_emac_tah.h
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, TAH support.
  *
  * Copyright 2004 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
+ * Copyright (c) 2005 Eugene Surovegin <ebs@ebshome.net>
+ *
  * 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
@@ -13,36 +17,72 @@
 #ifndef _IBM_EMAC_TAH_H
 #define _IBM_EMAC_TAH_H
 
+#include <linux/config.h>
+#include <linux/init.h>
+#include <asm/ocp.h>
+
 /* TAH */
-typedef struct tah_regs {
-        u32 tah_revid;
+struct tah_regs {
+        u32 revid;
         u32 pad[3];
-        u32 tah_mr;
-        u32 tah_ssr0;
-        u32 tah_ssr1;
-        u32 tah_ssr2;
-        u32 tah_ssr3;
-        u32 tah_ssr4;
-        u32 tah_ssr5;
-        u32 tah_tsr;
-} tah_t;
+        u32 mr;
+        u32 ssr0;
+        u32 ssr1;
+        u32 ssr2;
+        u32 ssr3;
+        u32 ssr4;
+        u32 ssr5;
+        u32 tsr;
+};
 
 /* TAH engine */
-#define TAH_MR_CVR                      0x80000000
-#define TAH_MR_SR                       0x40000000
-#define TAH_MR_ST_256                   0x01000000
-#define TAH_MR_ST_512                   0x02000000
-#define TAH_MR_ST_768                   0x03000000
-#define TAH_MR_ST_1024                  0x04000000
-#define TAH_MR_ST_1280                  0x05000000
-#define TAH_MR_ST_1536                  0x06000000
-#define TAH_MR_TFS_16KB                 0x00000000
-#define TAH_MR_TFS_2KB                  0x00200000
-#define TAH_MR_TFS_4KB                  0x00400000
-#define TAH_MR_TFS_6KB                  0x00600000
-#define TAH_MR_TFS_8KB                  0x00800000
-#define TAH_MR_TFS_10KB                 0x00a00000
-#define TAH_MR_DTFP                     0x00100000
-#define TAH_MR_DIG                      0x00080000
+#define TAH_MR_CVR              0x80000000
+#define TAH_MR_SR               0x40000000
+#define TAH_MR_ST_256           0x01000000
+#define TAH_MR_ST_512           0x02000000
+#define TAH_MR_ST_768           0x03000000
+#define TAH_MR_ST_1024          0x04000000
+#define TAH_MR_ST_1280          0x05000000
+#define TAH_MR_ST_1536          0x06000000
+#define TAH_MR_TFS_16KB         0x00000000
+#define TAH_MR_TFS_2KB          0x00200000
+#define TAH_MR_TFS_4KB          0x00400000
+#define TAH_MR_TFS_6KB          0x00600000
+#define TAH_MR_TFS_8KB          0x00800000
+#define TAH_MR_TFS_10KB         0x00a00000
+#define TAH_MR_DTFP             0x00100000
+#define TAH_MR_DIG              0x00080000
+
+#ifdef CONFIG_IBM_EMAC_TAH
+int tah_attach(void *emac) __init;
+
+void __tah_fini(struct ocp_device *ocpdev) __exit;
+static inline void tah_fini(struct ocp_device *ocpdev)
+{
+        if (ocpdev)
+                __tah_fini(ocpdev);
+}
+
+void __tah_reset(struct ocp_device *ocpdev);
+static inline void tah_reset(struct ocp_device *ocpdev)
+{
+        if (ocpdev)
+                __tah_reset(ocpdev);
+}
+
+int __tah_get_regs_len(struct ocp_device *ocpdev);
+static inline int tah_get_regs_len(struct ocp_device *ocpdev)
+{
+        return ocpdev ? __tah_get_regs_len(ocpdev) : 0;
+}
+
+void *tah_dump_regs(struct ocp_device *ocpdev, void *buf);
+#else
+# define tah_attach(x)          0
+# define tah_fini(x)            ((void)0)
+# define tah_reset(x)           ((void)0)
+# define tah_get_regs_len(x)    0
+# define tah_dump_regs(x,buf)   (buf)
+#endif                          /* !CONFIG_IBM_EMAC_TAH */
 
 #endif                          /* _IBM_EMAC_TAH_H */
diff --git a/drivers/net/ibm_emac/ibm_emac_zmii.c b/drivers/net/ibm_emac/ibm_emac_zmii.c
new file mode 100644
index 000000000000..35c1185079ed
--- /dev/null
+++ b/drivers/net/ibm_emac/ibm_emac_zmii.c
@@ -0,0 +1,255 @@
+/*
+ * drivers/net/ibm_emac/ibm_emac_zmii.c
+ *
+ * Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support.
+ *
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
+ *
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2001 MontaVista Softare Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/ethtool.h>
+#include <asm/io.h>
+
+#include "ibm_emac_core.h"
+#include "ibm_emac_debug.h"
+
+/* ZMIIx_FER */
+#define ZMII_FER_MDI(idx)       (0x80000000 >> ((idx) * 4))
+#define ZMII_FER_MDI_ALL        (ZMII_FER_MDI(0) | ZMII_FER_MDI(1) | \
+                                 ZMII_FER_MDI(2) | ZMII_FER_MDI(3))
+
+#define ZMII_FER_SMII(idx)      (0x40000000 >> ((idx) * 4))
+#define ZMII_FER_RMII(idx)      (0x20000000 >> ((idx) * 4))
+#define ZMII_FER_MII(idx)       (0x10000000 >> ((idx) * 4))
+
+/* ZMIIx_SSR */
+#define ZMII_SSR_SCI(idx)       (0x40000000 >> ((idx) * 4))
+#define ZMII_SSR_FSS(idx)       (0x20000000 >> ((idx) * 4))
+#define ZMII_SSR_SP(idx)        (0x10000000 >> ((idx) * 4))
+
+/* ZMII only supports MII, RMII and SMII 
+ * we also support autodetection for backward compatibility
+ */
+static inline int zmii_valid_mode(int mode)
+{
+        return  mode == PHY_MODE_MII ||
+                mode == PHY_MODE_RMII ||
+                mode == PHY_MODE_SMII ||
+                mode == PHY_MODE_NA;
+}
+
+static inline const char *zmii_mode_name(int mode)
+{
+        switch (mode) {
+        case PHY_MODE_MII:
+                return "MII";
+        case PHY_MODE_RMII:
+                return "RMII";
+        case PHY_MODE_SMII:
+                return "SMII";
+        default:
+                BUG();
+        }
+}
+
+static inline u32 zmii_mode_mask(int mode, int input)
+{
+        switch (mode) {
+        case PHY_MODE_MII:
+                return ZMII_FER_MII(input);
+        case PHY_MODE_RMII:
+                return ZMII_FER_RMII(input);
+        case PHY_MODE_SMII:
+                return ZMII_FER_SMII(input);
+        default:
+                return 0;
+        }
+}
+
+static int __init zmii_init(struct ocp_device *ocpdev, int input, int *mode)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        struct zmii_regs *p;
+
+        ZMII_DBG("%d: init(%d, %d)" NL, ocpdev->def->index, input, *mode);
+
+        if (!dev) {
+                dev = kzalloc(sizeof(struct ibm_ocp_zmii), GFP_KERNEL);
+                if (!dev) {
+                        printk(KERN_ERR
+                               "zmii%d: couldn't allocate device structure!\n",
+                               ocpdev->def->index);
+                        return -ENOMEM;
+                }
+                dev->mode = PHY_MODE_NA;
+
+                p = (struct zmii_regs *)ioremap(ocpdev->def->paddr,
+                                                sizeof(struct zmii_regs));
+                if (!p) {
+                        printk(KERN_ERR
+                               "zmii%d: could not ioremap device registers!\n",
+                               ocpdev->def->index);
+                        kfree(dev);
+                        return -ENOMEM;
+                }
+                dev->base = p;
+                ocp_set_drvdata(ocpdev, dev);
+                
+                /* We may need FER value for autodetection later */
+                dev->fer_save = in_be32(&p->fer);
+
+                /* Disable all inputs by default */
+                out_be32(&p->fer, 0);
+        } else
+                p = dev->base;
+
+        if (!zmii_valid_mode(*mode)) {
+                /* Probably an EMAC connected to RGMII, 
+                 * but it still may need ZMII for MDIO 
+                 */
+                goto out;
+        }
+
+        /* Autodetect ZMII mode if not specified.
+         * This is only for backward compatibility with the old driver.
+         * Please, always specify PHY mode in your board port to avoid
+         * any surprises.
+         */
+        if (dev->mode == PHY_MODE_NA) {
+                if (*mode == PHY_MODE_NA) {
+                        u32 r = dev->fer_save;
+
+                        ZMII_DBG("%d: autodetecting mode, FER = 0x%08x" NL,
+                                 ocpdev->def->index, r);
+                        
+                        if (r & (ZMII_FER_MII(0) | ZMII_FER_MII(1)))
+                                dev->mode = PHY_MODE_MII;
+                        else if (r & (ZMII_FER_RMII(0) | ZMII_FER_RMII(1)))
+                                dev->mode = PHY_MODE_RMII;
+                        else
+                                dev->mode = PHY_MODE_SMII;
+                } else
+                        dev->mode = *mode;
+
+                printk(KERN_NOTICE "zmii%d: bridge in %s mode\n",
+                       ocpdev->def->index, zmii_mode_name(dev->mode));
+        } else {
+                /* All inputs must use the same mode */
+                if (*mode != PHY_MODE_NA && *mode != dev->mode) {
+                        printk(KERN_ERR
+                               "zmii%d: invalid mode %d specified for input %d\n",
+                               ocpdev->def->index, *mode, input);
+                        return -EINVAL;
+                }
+        }
+
+        /* Report back correct PHY mode, 
+         * it may be used during PHY initialization.
+         */
+        *mode = dev->mode;
+
+        /* Enable this input */
+        out_be32(&p->fer, in_be32(&p->fer) | zmii_mode_mask(dev->mode, input));
+      out:
+        ++dev->users;
+        return 0;
+}
+
+int __init zmii_attach(void *emac)
+{
+        struct ocp_enet_private *dev = emac;
+        struct ocp_func_emac_data *emacdata = dev->def->additions;
+
+        if (emacdata->zmii_idx >= 0) {
+                dev->zmii_input = emacdata->zmii_mux;
+                dev->zmii_dev =
+                    ocp_find_device(OCP_VENDOR_IBM, OCP_FUNC_ZMII,
+                                    emacdata->zmii_idx);
+                if (!dev->zmii_dev) {
+                        printk(KERN_ERR "emac%d: unknown zmii%d!\n",
+                               dev->def->index, emacdata->zmii_idx);
+                        return -ENODEV;
+                }
+                if (zmii_init
+                    (dev->zmii_dev, dev->zmii_input, &emacdata->phy_mode)) {
+                        printk(KERN_ERR
+                               "emac%d: zmii%d initialization failed!\n",
+                               dev->def->index, emacdata->zmii_idx);
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+void __zmii_enable_mdio(struct ocp_device *ocpdev, int input)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        u32 fer = in_be32(&dev->base->fer) & ~ZMII_FER_MDI_ALL;
+
+        ZMII_DBG2("%d: mdio(%d)" NL, ocpdev->def->index, input);
+
+        out_be32(&dev->base->fer, fer | ZMII_FER_MDI(input));
+}
+
+void __zmii_set_speed(struct ocp_device *ocpdev, int input, int speed)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        u32 ssr = in_be32(&dev->base->ssr);
+
+        ZMII_DBG("%d: speed(%d, %d)" NL, ocpdev->def->index, input, speed);
+
+        if (speed == SPEED_100)
+                ssr |= ZMII_SSR_SP(input);
+        else
+                ssr &= ~ZMII_SSR_SP(input);
+
+        out_be32(&dev->base->ssr, ssr);
+}
+
+void __exit __zmii_fini(struct ocp_device *ocpdev, int input)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        BUG_ON(!dev || dev->users == 0);
+
+        ZMII_DBG("%d: fini(%d)" NL, ocpdev->def->index, input);
+
+        /* Disable this input */
+        out_be32(&dev->base->fer,
+                 in_be32(&dev->base->fer) & ~zmii_mode_mask(dev->mode, input));
+
+        if (!--dev->users) {
+                /* Free everything if this is the last user */
+                ocp_set_drvdata(ocpdev, NULL);
+                iounmap((void *)dev->base);
+                kfree(dev);
+        }
+}
+
+int __zmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return sizeof(struct emac_ethtool_regs_subhdr) +
+            sizeof(struct zmii_regs);
+}
+
+void *zmii_dump_regs(struct ocp_device *ocpdev, void *buf)
+{
+        struct ibm_ocp_zmii *dev = ocp_get_drvdata(ocpdev);
+        struct emac_ethtool_regs_subhdr *hdr = buf;
+        struct zmii_regs *regs = (struct zmii_regs *)(hdr + 1);
+
+        hdr->version = 0;
+        hdr->index = ocpdev->def->index;
+        memcpy_fromio(regs, dev->base, sizeof(struct zmii_regs));
+        return regs + 1;
+}
diff --git a/drivers/net/ibm_emac/ibm_emac_zmii.h b/drivers/net/ibm_emac/ibm_emac_zmii.h
index 6f6cd2a39e38..0bb26062c0ad 100644
--- a/drivers/net/ibm_emac/ibm_emac_zmii.h
+++ b/drivers/net/ibm_emac/ibm_emac_zmii.h
@@ -1,23 +1,27 @@
 /*
- * ocp_zmii.h
+ * drivers/net/ibm_emac/ibm_emac_zmii.h
  *
- * Defines for the IBM ZMII bridge
+ * Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support.
  *
- *      Armin Kuster akuster@mvista.com
- *      Dec, 2001
+ * Copyright (c) 2004, 2005 Zultys Technologies.
+ * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
  *
- * Copyright 2001 MontaVista Softare Inc.
+ * Based on original work by
+ *      Armin Kuster <akuster@mvista.com>
+ *      Copyright 2001 MontaVista Softare Inc.
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
  * Free Software Foundation;  either version 2 of the  License, or (at your
  * option) any later version.
+ *
  */
-
 #ifndef _IBM_EMAC_ZMII_H_
 #define _IBM_EMAC_ZMII_H_
 
 #include <linux/config.h>
+#include <linux/init.h>
+#include <asm/ocp.h>
 
 /* ZMII bridge registers */
 struct zmii_regs {
@@ -26,68 +30,54 @@ struct zmii_regs {
         u32 smiirs;             /* SMII status reg */
 };
 
-#define ZMII_INPUTS     4
-
 /* ZMII device */
 struct ibm_ocp_zmii {
         struct zmii_regs *base;
-        int mode[ZMII_INPUTS];
+        int mode;               /* subset of PHY_MODE_XXXX */
         int users;              /* number of EMACs using this ZMII bridge */
+        u32 fer_save;           /* FER value left by firmware */
 };
 
-/* Fuctional Enable Reg */
-
-#define ZMII_FER_MASK(x)        (0xf0000000 >> (4*x))
-
-#define ZMII_MDI0       0x80000000
-#define ZMII_SMII0      0x40000000
-#define ZMII_RMII0      0x20000000
-#define ZMII_MII0       0x10000000
-#define ZMII_MDI1       0x08000000
-#define ZMII_SMII1      0x04000000
-#define ZMII_RMII1      0x02000000
-#define ZMII_MII1       0x01000000
-#define ZMII_MDI2       0x00800000
-#define ZMII_SMII2      0x00400000
-#define ZMII_RMII2      0x00200000
-#define ZMII_MII2       0x00100000
-#define ZMII_MDI3       0x00080000
-#define ZMII_SMII3      0x00040000
-#define ZMII_RMII3      0x00020000
-#define ZMII_MII3       0x00010000
+#ifdef CONFIG_IBM_EMAC_ZMII
+int zmii_attach(void *emac) __init;
 
-/* Speed Selection reg */
+void __zmii_fini(struct ocp_device *ocpdev, int input) __exit;
+static inline void zmii_fini(struct ocp_device *ocpdev, int input)
+{
+        if (ocpdev)
+                __zmii_fini(ocpdev, input);
+}
 
-#define ZMII_SCI0       0x40000000
-#define ZMII_FSS0       0x20000000
-#define ZMII_SP0        0x10000000
-#define ZMII_SCI1       0x04000000
-#define ZMII_FSS1       0x02000000
-#define ZMII_SP1        0x01000000
-#define ZMII_SCI2       0x00400000
-#define ZMII_FSS2       0x00200000
-#define ZMII_SP2        0x00100000
-#define ZMII_SCI3       0x00040000
-#define ZMII_FSS3       0x00020000
-#define ZMII_SP3        0x00010000
+void __zmii_enable_mdio(struct ocp_device *ocpdev, int input);
+static inline void zmii_enable_mdio(struct ocp_device *ocpdev, int input)
+{
+        if (ocpdev)
+                __zmii_enable_mdio(ocpdev, input);
+}
 
-#define ZMII_MII0_100MB ZMII_SP0
-#define ZMII_MII0_10MB  ~ZMII_SP0
-#define ZMII_MII1_100MB ZMII_SP1
-#define ZMII_MII1_10MB  ~ZMII_SP1
-#define ZMII_MII2_100MB ZMII_SP2
-#define ZMII_MII2_10MB  ~ZMII_SP2
-#define ZMII_MII3_100MB ZMII_SP3
-#define ZMII_MII3_10MB  ~ZMII_SP3
+void __zmii_set_speed(struct ocp_device *ocpdev, int input, int speed);
+static inline void zmii_set_speed(struct ocp_device *ocpdev, int input,
+                                  int speed)
+{
+        if (ocpdev)
+                __zmii_set_speed(ocpdev, input, speed);
+}
 
-/* SMII Status reg */
+int __zmii_get_regs_len(struct ocp_device *ocpdev);
+static inline int zmii_get_regs_len(struct ocp_device *ocpdev)
+{
+        return ocpdev ? __zmii_get_regs_len(ocpdev) : 0;
+}
 
-#define ZMII_STS0 0xFF000000    /* EMAC0 smii status mask */
-#define ZMII_STS1 0x00FF0000    /* EMAC1 smii status mask */
+void *zmii_dump_regs(struct ocp_device *ocpdev, void *buf);
 
-#define SMII    0
-#define RMII    1
-#define MII     2
-#define MDI     3
+#else
+# define zmii_attach(x)         0
+# define zmii_fini(x,y)         ((void)0)
+# define zmii_enable_mdio(x,y)  ((void)0)
+# define zmii_set_speed(x,y,z)  ((void)0)
+# define zmii_get_regs_len(x)   0
+# define zmii_dump_regs(x,buf)  (buf)
+#endif                          /* !CONFIG_IBM_EMAC_ZMII */
 
 #endif                          /* _IBM_EMAC_ZMII_H_ */
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index a2c4dd4fb221..e5246f227c98 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -96,7 +96,7 @@ static void ibmveth_proc_unregister_driver(void);
 static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter);
 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter);
 static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
-static inline void ibmveth_schedule_replenishing(struct ibmveth_adapter*);
+static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
 
 #ifdef CONFIG_PROC_FS
 #define IBMVETH_PROC_DIR "net/ibmveth"
@@ -181,6 +181,7 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
         atomic_set(&pool->available, 0);
         pool->producer_index = 0;
         pool->consumer_index = 0;
+        pool->active = 0;
 
         return 0;
 }
@@ -236,7 +237,7 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                 lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
                     
                 if(lpar_rc != H_Success) {
-                        pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
+                        pool->free_map[free_index] = index;
                         pool->skbuff[index] = NULL;
                         pool->consumer_index--;
                         dma_unmap_single(&adapter->vdev->dev,
@@ -255,37 +256,19 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
         atomic_add(buffers_added, &(pool->available));
 }
 
-/* check if replenishing is needed.  */
-static inline int ibmveth_is_replenishing_needed(struct ibmveth_adapter *adapter)
-{
-        return ((atomic_read(&adapter->rx_buff_pool[0].available) < adapter->rx_buff_pool[0].threshold) ||
-                (atomic_read(&adapter->rx_buff_pool[1].available) < adapter->rx_buff_pool[1].threshold) ||
-                (atomic_read(&adapter->rx_buff_pool[2].available) < adapter->rx_buff_pool[2].threshold));
-}
-
-/* kick the replenish tasklet if we need replenishing and it isn't already running */
-static inline void ibmveth_schedule_replenishing(struct ibmveth_adapter *adapter)
-{
-        if(ibmveth_is_replenishing_needed(adapter) &&
-           (atomic_dec_if_positive(&adapter->not_replenishing) == 0)) {
-                schedule_work(&adapter->replenish_task);
-        }
-}
-
-/* replenish tasklet routine */
+/* replenish routine */
 static void ibmveth_replenish_task(struct ibmveth_adapter *adapter) 
 {
+        int i;
+
         adapter->replenish_task_cycles++;
 
-        ibmveth_replenish_buffer_pool(adapter, &adapter->rx_buff_pool[0]);
-        ibmveth_replenish_buffer_pool(adapter, &adapter->rx_buff_pool[1]);
-        ibmveth_replenish_buffer_pool(adapter, &adapter->rx_buff_pool[2]);
+        for(i = 0; i < IbmVethNumBufferPools; i++)
+                if(adapter->rx_buff_pool[i].active)
+                        ibmveth_replenish_buffer_pool(adapter, 
+                                                     &adapter->rx_buff_pool[i]);
 
         adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
-
-        atomic_inc(&adapter->not_replenishing);
-
-        ibmveth_schedule_replenishing(adapter);
 }
 
 /* empty and free ana buffer pool - also used to do cleanup in error paths */
@@ -293,10 +276,8 @@ static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibm
 {
         int i;
 
-        if(pool->free_map) {
-                kfree(pool->free_map);
-                pool->free_map  = NULL;
-        }
+        kfree(pool->free_map);
+        pool->free_map = NULL;
 
         if(pool->skbuff && pool->dma_addr) {
                 for(i = 0; i < pool->size; ++i) {
@@ -321,6 +302,7 @@ static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibm
                 kfree(pool->skbuff);
                 pool->skbuff = NULL;
         }
+        pool->active = 0;
 }
 
 /* remove a buffer from a pool */
@@ -379,6 +361,12 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
         ibmveth_assert(pool < IbmVethNumBufferPools);
         ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
 
+        if(!adapter->rx_buff_pool[pool].active) {
+                ibmveth_rxq_harvest_buffer(adapter);
+                ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
+                return;
+        }
+
         desc.desc = 0;
         desc.fields.valid = 1;
         desc.fields.length = adapter->rx_buff_pool[pool].buff_size;
@@ -409,6 +397,8 @@ static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
 
 static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
 {
+        int i;
+
         if(adapter->buffer_list_addr != NULL) {
                 if(!dma_mapping_error(adapter->buffer_list_dma)) {
                         dma_unmap_single(&adapter->vdev->dev,
@@ -443,26 +433,24 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
                 adapter->rx_queue.queue_addr = NULL;
         }
 
-        ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[0]);
-        ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[1]);
-        ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[2]);
+        for(i = 0; i<IbmVethNumBufferPools; i++)
+                ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[i]);
 }
 
 static int ibmveth_open(struct net_device *netdev)
 {
         struct ibmveth_adapter *adapter = netdev->priv;
         u64 mac_address = 0;
-        int rxq_entries;
+        int rxq_entries = 1;
         unsigned long lpar_rc;
         int rc;
         union ibmveth_buf_desc rxq_desc;
+        int i;
 
         ibmveth_debug_printk("open starting\n");
 
-        rxq_entries =
-                adapter->rx_buff_pool[0].size +
-                adapter->rx_buff_pool[1].size +
-                adapter->rx_buff_pool[2].size + 1;
+        for(i = 0; i<IbmVethNumBufferPools; i++)
+                rxq_entries += adapter->rx_buff_pool[i].size;
     
         adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
         adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
@@ -502,14 +490,8 @@ static int ibmveth_open(struct net_device *netdev)
         adapter->rx_queue.num_slots = rxq_entries;
         adapter->rx_queue.toggle = 1;
 
-        if(ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[0]) ||
-           ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[1]) ||
-           ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[2]))
-        {
-                ibmveth_error_printk("unable to allocate buffer pools\n");
-                ibmveth_cleanup(adapter);
-                return -ENOMEM;
-        }
+        /* call change_mtu to init the buffer pools based in initial mtu */
+        ibmveth_change_mtu(netdev, netdev->mtu);
 
         memcpy(&mac_address, netdev->dev_addr, netdev->addr_len);
         mac_address = mac_address >> 16;
@@ -532,7 +514,7 @@ static int ibmveth_open(struct net_device *netdev)
 
         if(lpar_rc != H_Success) {
                 ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc);
-                ibmveth_error_printk("buffer TCE:0x%x filter TCE:0x%x rxq desc:0x%lx MAC:0x%lx\n",
+                ibmveth_error_printk("buffer TCE:0x%lx filter TCE:0x%lx rxq desc:0x%lx MAC:0x%lx\n",
                                      adapter->buffer_list_dma,
                                      adapter->filter_list_dma,
                                      rxq_desc.desc,
@@ -552,10 +534,10 @@ static int ibmveth_open(struct net_device *netdev)
                 return rc;
         }
 
-        netif_start_queue(netdev);
+        ibmveth_debug_printk("initial replenish cycle\n");
+        ibmveth_replenish_task(adapter);
 
-        ibmveth_debug_printk("scheduling initial replenish cycle\n");
-        ibmveth_schedule_replenishing(adapter);
+        netif_start_queue(netdev);
 
         ibmveth_debug_printk("open complete\n");
 
@@ -573,9 +555,6 @@ static int ibmveth_close(struct net_device *netdev)
 
         free_irq(netdev->irq, netdev);
 
-        cancel_delayed_work(&adapter->replenish_task);
-        flush_scheduled_work();
-
         do {
                 lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
         } while (H_isLongBusy(lpar_rc) || (lpar_rc == H_Busy));
@@ -640,12 +619,18 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
         unsigned long lpar_rc;
         int nfrags = 0, curfrag;
         unsigned long correlator;
+        unsigned long flags;
         unsigned int retry_count;
+        unsigned int tx_dropped = 0;
+        unsigned int tx_bytes = 0;
+        unsigned int tx_packets = 0;
+        unsigned int tx_send_failed = 0;
+        unsigned int tx_map_failed = 0;
+
 
         if ((skb_shinfo(skb)->nr_frags + 1) > IbmVethMaxSendFrags) {
-                adapter->stats.tx_dropped++;
-                dev_kfree_skb(skb);
-                return 0;
+                tx_dropped++;
+                goto out;
         }
 
         memset(&desc, 0, sizeof(desc));
@@ -664,10 +649,9 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 
         if(dma_mapping_error(desc[0].fields.address)) {
                 ibmveth_error_printk("tx: unable to map initial fragment\n");
-                adapter->tx_map_failed++;
-                adapter->stats.tx_dropped++;
-                dev_kfree_skb(skb);
-                return 0;
+                tx_map_failed++;
+                tx_dropped++;
+                goto out;
         }
 
         curfrag = nfrags;
@@ -684,8 +668,8 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 
                 if(dma_mapping_error(desc[curfrag+1].fields.address)) {
                         ibmveth_error_printk("tx: unable to map fragment %d\n", curfrag);
-                        adapter->tx_map_failed++;
-                        adapter->stats.tx_dropped++;
+                        tx_map_failed++;
+                        tx_dropped++;
                         /* Free all the mappings we just created */
                         while(curfrag < nfrags) {
                                 dma_unmap_single(&adapter->vdev->dev,
@@ -694,8 +678,7 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                                  DMA_TO_DEVICE);
                                 curfrag++;
                         }
-                        dev_kfree_skb(skb);
-                        return 0;
+                        goto out;
                 }
         }
 
@@ -720,11 +703,12 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                         ibmveth_error_printk("tx: desc[%i] valid=%d, len=%d, address=0x%d\n", i,
                                              desc[i].fields.valid, desc[i].fields.length, desc[i].fields.address);
                 }
-                adapter->tx_send_failed++;
-                adapter->stats.tx_dropped++;
+                tx_send_failed++;
+                tx_dropped++;
         } else {
-                adapter->stats.tx_packets++;
-                adapter->stats.tx_bytes += skb->len;
+                tx_packets++;
+                tx_bytes += skb->len;
+                netdev->trans_start = jiffies;
         }
 
         do {
@@ -733,6 +717,14 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                 desc[nfrags].fields.length, DMA_TO_DEVICE);
         } while(--nfrags >= 0);
 
+out:    spin_lock_irqsave(&adapter->stats_lock, flags);
+        adapter->stats.tx_dropped += tx_dropped;
+        adapter->stats.tx_bytes += tx_bytes;
+        adapter->stats.tx_packets += tx_packets;
+        adapter->tx_send_failed += tx_send_failed;
+        adapter->tx_map_failed += tx_map_failed;
+        spin_unlock_irqrestore(&adapter->stats_lock, flags);
+
         dev_kfree_skb(skb);
         return 0;
 }
@@ -776,13 +768,14 @@ static int ibmveth_poll(struct net_device *netdev, int *budget)
                                 adapter->stats.rx_packets++;
                                 adapter->stats.rx_bytes += length;
                                 frames_processed++;
+                                netdev->last_rx = jiffies;
                         }
                 } else {
                         more_work = 0;
                 }
         } while(more_work && (frames_processed < max_frames_to_process));
 
-        ibmveth_schedule_replenishing(adapter);
+        ibmveth_replenish_task(adapter);
 
         if(more_work) {
                 /* more work to do - return that we are not done yet */
@@ -883,17 +876,54 @@ static void ibmveth_set_multicast_list(struct net_device *netdev)
 
 static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
 {
-        if ((new_mtu < 68) || (new_mtu > (1<<20)))
+        struct ibmveth_adapter *adapter = dev->priv;
+        int i;
+        int prev_smaller = 1;
+
+        if ((new_mtu < 68) || 
+            (new_mtu > (pool_size[IbmVethNumBufferPools-1]) - IBMVETH_BUFF_OH))
                 return -EINVAL;
+
+        for(i = 0; i<IbmVethNumBufferPools; i++) {
+                int activate = 0;
+                if (new_mtu > (pool_size[i]  - IBMVETH_BUFF_OH)) { 
+                        activate = 1;
+                        prev_smaller= 1;
+                } else {
+                        if (prev_smaller)
+                                activate = 1;
+                        prev_smaller= 0;
+                }
+
+                if (activate && !adapter->rx_buff_pool[i].active) {
+                        struct ibmveth_buff_pool *pool = 
+                                                &adapter->rx_buff_pool[i];
+                        if(ibmveth_alloc_buffer_pool(pool)) {
+                                ibmveth_error_printk("unable to alloc pool\n");
+                                return -ENOMEM;
+                        }
+                        adapter->rx_buff_pool[i].active = 1;
+                } else if (!activate && adapter->rx_buff_pool[i].active) {
+                        adapter->rx_buff_pool[i].active = 0;
+                        h_free_logical_lan_buffer(adapter->vdev->unit_address,
+                                          (u64)pool_size[i]);
+                }
+
+        }
+
+        /* kick the interrupt handler so that the new buffer pools get
+           replenished or deallocated */
+        ibmveth_interrupt(dev->irq, dev, NULL);
+
         dev->mtu = new_mtu;
         return 0;       
 }
 
 static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
 {
-        int rc;
+        int rc, i;
         struct net_device *netdev;
-        struct ibmveth_adapter *adapter;
+        struct ibmveth_adapter *adapter = NULL;
 
         unsigned char *mac_addr_p;
         unsigned int *mcastFilterSize_p;
@@ -960,23 +990,21 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
         netdev->ethtool_ops           = &netdev_ethtool_ops;
         netdev->change_mtu         = ibmveth_change_mtu;
         SET_NETDEV_DEV(netdev, &dev->dev);
+        netdev->features |= NETIF_F_LLTX; 
+        spin_lock_init(&adapter->stats_lock);
 
         memcpy(&netdev->dev_addr, &adapter->mac_addr, netdev->addr_len);
 
-        ibmveth_init_buffer_pool(&adapter->rx_buff_pool[0], 0, IbmVethPool0DftCnt, IbmVethPool0DftSize);
-        ibmveth_init_buffer_pool(&adapter->rx_buff_pool[1], 1, IbmVethPool1DftCnt, IbmVethPool1DftSize);
-        ibmveth_init_buffer_pool(&adapter->rx_buff_pool[2], 2, IbmVethPool2DftCnt, IbmVethPool2DftSize);
+        for(i = 0; i<IbmVethNumBufferPools; i++)
+                ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i, 
+                                         pool_count[i], pool_size[i]);
 
         ibmveth_debug_printk("adapter @ 0x%p\n", adapter);
 
-        INIT_WORK(&adapter->replenish_task, (void*)ibmveth_replenish_task, (void*)adapter);
-
         adapter->buffer_list_dma = DMA_ERROR_CODE;
         adapter->filter_list_dma = DMA_ERROR_CODE;
         adapter->rx_queue.queue_dma = DMA_ERROR_CODE;
 
-        atomic_set(&adapter->not_replenishing, 1);
-
         ibmveth_debug_printk("registering netdev...\n");
 
         rc = register_netdev(netdev);
@@ -1146,14 +1174,16 @@ static struct vio_device_id ibmveth_device_table[] __devinitdata= {
         { "network", "IBM,l-lan"},
         { "", "" }
 };
-
 MODULE_DEVICE_TABLE(vio, ibmveth_device_table);
 
 static struct vio_driver ibmveth_driver = {
-        .name        = (char *)ibmveth_driver_name,
-        .id_table    = ibmveth_device_table,
-        .probe       = ibmveth_probe,
-        .remove      = ibmveth_remove
+        .id_table       = ibmveth_device_table,
+        .probe          = ibmveth_probe,
+        .remove         = ibmveth_remove,
+        .driver         = {
+                .name   = ibmveth_driver_name,
+                .owner  = THIS_MODULE,
+        }
 };
 
 static int __init ibmveth_module_init(void)
diff --git a/drivers/net/ibmveth.h b/drivers/net/ibmveth.h
index 51a470da9686..46919a814fca 100644
--- a/drivers/net/ibmveth.h
+++ b/drivers/net/ibmveth.h
@@ -49,6 +49,7 @@
 #define H_SEND_LOGICAL_LAN       0x120
 #define H_MULTICAST_CTRL         0x130
 #define H_CHANGE_LOGICAL_LAN_MAC 0x14C
+#define H_FREE_LOGICAL_LAN_BUFFER 0x1D4
 
 /* hcall macros */
 #define h_register_logical_lan(ua, buflst, rxq, fltlst, mac) \
@@ -69,13 +70,15 @@
 #define h_change_logical_lan_mac(ua, mac) \
   plpar_hcall_norets(H_CHANGE_LOGICAL_LAN_MAC, ua, mac)
 
-#define IbmVethNumBufferPools 3
-#define IbmVethPool0DftSize (1024 * 2)
-#define IbmVethPool1DftSize (1024 * 4)
-#define IbmVethPool2DftSize (1024 * 10)
-#define IbmVethPool0DftCnt  256
-#define IbmVethPool1DftCnt  256
-#define IbmVethPool2DftCnt  256
+#define h_free_logical_lan_buffer(ua, bufsize) \
+  plpar_hcall_norets(H_FREE_LOGICAL_LAN_BUFFER, ua, bufsize)
+
+#define IbmVethNumBufferPools 5
+#define IBMVETH_BUFF_OH 22 /* Overhead: 14 ethernet header + 8 opaque handle */
+
+/* pool_size should be sorted */
+static int pool_size[] = { 512, 1024 * 2, 1024 * 16, 1024 * 32, 1024 * 64 };
+static int pool_count[] = { 256, 768, 256, 256, 256 };
 
 #define IBM_VETH_INVALID_MAP ((u16)0xffff)
 
@@ -90,6 +93,7 @@ struct ibmveth_buff_pool {
     u16 *free_map;
     dma_addr_t *dma_addr;
     struct sk_buff **skbuff;
+    int active;
 };
 
 struct ibmveth_rx_q {
@@ -114,10 +118,6 @@ struct ibmveth_adapter {
     dma_addr_t filter_list_dma;
     struct ibmveth_buff_pool rx_buff_pool[IbmVethNumBufferPools];
     struct ibmveth_rx_q rx_queue;
-    atomic_t not_replenishing;
-
-    /* helper tasks */
-    struct work_struct replenish_task;
 
     /* adapter specific stats */
     u64 replenish_task_cycles;
@@ -131,6 +131,7 @@ struct ibmveth_adapter {
     u64 tx_linearize_failed;
     u64 tx_map_failed;
     u64 tx_send_failed;
+    spinlock_t stats_lock;
 };
 
 struct ibmveth_buf_desc_fields {        
diff --git a/drivers/net/irda/donauboe.c b/drivers/net/irda/donauboe.c
index 0a08c539c051..0282771b1cbb 100644
--- a/drivers/net/irda/donauboe.c
+++ b/drivers/net/irda/donauboe.c
@@ -1695,11 +1695,9 @@ toshoboe_open (struct pci_dev *pci_dev, const struct pci_device_id *pdid)
 
 freebufs:
   for (i = 0; i < TX_SLOTS; ++i)
-    if (self->tx_bufs[i])
-      kfree (self->tx_bufs[i]);
+    kfree (self->tx_bufs[i]);
   for (i = 0; i < RX_SLOTS; ++i)
-    if (self->rx_bufs[i])
-      kfree (self->rx_bufs[i]);
+    kfree (self->rx_bufs[i]);
   kfree(self->ringbuf);
 
 freeregion:
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 6c766fdc51a6..c22c0517883c 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1168,10 +1168,8 @@ static inline void irda_usb_close(struct irda_usb_cb *self)
         unregister_netdev(self->netdev);
 
         /* Remove the speed buffer */
-        if (self->speed_buff != NULL) {
-                kfree(self->speed_buff);
-                self->speed_buff = NULL;
-        }
+        kfree(self->speed_buff);
+        self->speed_buff = NULL;
 }
 
 /********************** USB CONFIG SUBROUTINES **********************/
diff --git a/drivers/net/irda/irport.c b/drivers/net/irda/irport.c
index 5971315f3fa0..3d016a498e1d 100644
--- a/drivers/net/irda/irport.c
+++ b/drivers/net/irda/irport.c
@@ -235,8 +235,7 @@ static int irport_close(struct irport_cb *self)
                    __FUNCTION__, self->io.sir_base);
         release_region(self->io.sir_base, self->io.sir_ext);
 
-        if (self->tx_buff.head)
-                kfree(self->tx_buff.head);
+        kfree(self->tx_buff.head);
         
         if (self->rx_buff.skb)
                 kfree_skb(self->rx_buff.skb);
diff --git a/drivers/net/irda/pxaficp_ir.c b/drivers/net/irda/pxaficp_ir.c
index 9571145c2090..e1aa9910503b 100644
--- a/drivers/net/irda/pxaficp_ir.c
+++ b/drivers/net/irda/pxaficp_ir.c
@@ -705,15 +705,12 @@ static int pxa_irda_stop(struct net_device *dev)
         return 0;
 }
 
-static int pxa_irda_suspend(struct device *_dev, pm_message_t state, u32 level)
+static int pxa_irda_suspend(struct device *_dev, pm_message_t state)
 {
         struct net_device *dev = dev_get_drvdata(_dev);
         struct pxa_irda *si;
 
-        if (!dev || level != SUSPEND_DISABLE)
-                return 0;
-
-        if (netif_running(dev)) {
+        if (dev && netif_running(dev)) {
                 si = netdev_priv(dev);
                 netif_device_detach(dev);
                 pxa_irda_shutdown(si);
@@ -722,15 +719,12 @@ static int pxa_irda_suspend(struct device *_dev, pm_message_t state, u32 level)
         return 0;
 }
 
-static int pxa_irda_resume(struct device *_dev, u32 level)
+static int pxa_irda_resume(struct device *_dev)
 {
         struct net_device *dev = dev_get_drvdata(_dev);
         struct pxa_irda *si;
 
-        if (!dev || level != RESUME_ENABLE)
-                return 0;
-
-        if (netif_running(dev)) {
+        if (dev && netif_running(dev)) {
                 si = netdev_priv(dev);
                 pxa_irda_startup(si);
                 netif_device_attach(dev);
diff --git a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c
index efc5a8870565..df22b8b532e7 100644
--- a/drivers/net/irda/sir_dev.c
+++ b/drivers/net/irda/sir_dev.c
@@ -490,8 +490,7 @@ static void sirdev_free_buffers(struct sir_dev *dev)
 {
         if (dev->rx_buff.skb)
                 kfree_skb(dev->rx_buff.skb);
-        if (dev->tx_buff.head)
-                kfree(dev->tx_buff.head);
+        kfree(dev->tx_buff.head);
         dev->rx_buff.head = dev->tx_buff.head = NULL;
         dev->rx_buff.skb = NULL;
 }
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index 424515d35932..a1d207f2fa68 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -639,21 +639,14 @@ static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self)
  */
 static void smsc_ircc_init_chip(struct smsc_ircc_cb *self)
 {
-        int iobase, ir_mode, ctrl, fast;
-
-        IRDA_ASSERT(self != NULL, return;);
-
-        iobase = self->io.fir_base;
-        ir_mode = IRCC_CFGA_IRDA_SIR_A;
-        ctrl = 0;
-        fast = 0;
+        int iobase = self->io.fir_base;
 
         register_bank(iobase, 0);
         outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
         outb(0x00, iobase + IRCC_MASTER);
 
         register_bank(iobase, 1);
-        outb(((inb(iobase + IRCC_SCE_CFGA) & 0x87) | ir_mode),
+        outb(((inb(iobase + IRCC_SCE_CFGA) & 0x87) | IRCC_CFGA_IRDA_SIR_A),
              iobase + IRCC_SCE_CFGA);
 
 #ifdef smsc_669 /* Uses pin 88/89 for Rx/Tx */
@@ -667,10 +660,10 @@ static void smsc_ircc_init_chip(struct smsc_ircc_cb *self)
         outb(SMSC_IRCC2_FIFO_THRESHOLD, iobase + IRCC_FIFO_THRESHOLD);
 
         register_bank(iobase, 4);
-        outb((inb(iobase + IRCC_CONTROL) & 0x30) | ctrl, iobase + IRCC_CONTROL);
+        outb((inb(iobase + IRCC_CONTROL) & 0x30), iobase + IRCC_CONTROL);
 
         register_bank(iobase, 0);
-        outb(fast, iobase + IRCC_LCR_A);
+        outb(0, iobase + IRCC_LCR_A);
 
         smsc_ircc_set_sir_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
 
@@ -1557,6 +1550,46 @@ static int ircc_is_receiving(struct smsc_ircc_cb *self)
 }
 #endif /* unused */
 
+static int smsc_ircc_request_irq(struct smsc_ircc_cb *self)
+{
+        int error;
+
+        error = request_irq(self->io.irq, smsc_ircc_interrupt, 0,
+                            self->netdev->name, self->netdev);
+        if (error)
+                IRDA_DEBUG(0, "%s(), unable to allocate irq=%d, err=%d\n",
+                           __FUNCTION__, self->io.irq, error);
+
+        return error;
+}
+
+static void smsc_ircc_start_interrupts(struct smsc_ircc_cb *self)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&self->lock, flags);
+
+        self->io.speed = 0;
+        smsc_ircc_change_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
+
+        spin_unlock_irqrestore(&self->lock, flags);
+}
+
+static void smsc_ircc_stop_interrupts(struct smsc_ircc_cb *self)
+{
+        int iobase = self->io.fir_base;
+        unsigned long flags;
+
+        spin_lock_irqsave(&self->lock, flags);
+
+        register_bank(iobase, 0);
+        outb(0, iobase + IRCC_IER);
+        outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
+        outb(0x00, iobase + IRCC_MASTER);
+
+        spin_unlock_irqrestore(&self->lock, flags);
+}
+
 
 /*
  * Function smsc_ircc_net_open (dev)
@@ -1568,7 +1601,6 @@ static int smsc_ircc_net_open(struct net_device *dev)
 {
         struct smsc_ircc_cb *self;
         char hwname[16];
-        unsigned long flags;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
@@ -1576,6 +1608,11 @@ static int smsc_ircc_net_open(struct net_device *dev)
         self = netdev_priv(dev);
         IRDA_ASSERT(self != NULL, return 0;);
 
+        if (self->io.suspended) {
+                IRDA_DEBUG(0, "%s(), device is suspended\n", __FUNCTION__);
+                return -EAGAIN;
+        }
+
         if (request_irq(self->io.irq, smsc_ircc_interrupt, 0, dev->name,
                         (void *) dev)) {
                 IRDA_DEBUG(0, "%s(), unable to allocate irq=%d\n",
@@ -1583,11 +1620,7 @@ static int smsc_ircc_net_open(struct net_device *dev)
                 return -EAGAIN;
         }
 
-        spin_lock_irqsave(&self->lock, flags);
-        /*smsc_ircc_sir_start(self);*/
-        self->io.speed = 0;
-        smsc_ircc_change_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
-        spin_unlock_irqrestore(&self->lock, flags);
+        smsc_ircc_start_interrupts(self);
 
         /* Give self a hardware name */
         /* It would be cool to offer the chip revision here - Jean II */
@@ -1640,7 +1673,12 @@ static int smsc_ircc_net_close(struct net_device *dev)
                 irlap_close(self->irlap);
         self->irlap = NULL;
 
-        free_irq(self->io.irq, dev);
+        smsc_ircc_stop_interrupts(self);
+
+        /* if we are called from smsc_ircc_resume we don't have IRQ reserved */
+        if (!self->io.suspended)
+                free_irq(self->io.irq, dev);
+
         disable_dma(self->io.dma);
         free_dma(self->io.dma);
 
@@ -1651,11 +1689,18 @@ static int smsc_ircc_suspend(struct device *dev, pm_message_t state)
 {
         struct smsc_ircc_cb *self = dev_get_drvdata(dev);
 
-        IRDA_MESSAGE("%s, Suspending\n", driver_name);
-
         if (!self->io.suspended) {
-                smsc_ircc_net_close(self->netdev);
+                IRDA_DEBUG(1, "%s, Suspending\n", driver_name);
+
+                rtnl_lock();
+                if (netif_running(self->netdev)) {
+                        netif_device_detach(self->netdev);
+                        smsc_ircc_stop_interrupts(self);
+                        free_irq(self->io.irq, self->netdev);
+                        disable_dma(self->io.dma);
+                }
                 self->io.suspended = 1;
+                rtnl_unlock();
         }
 
         return 0;
@@ -1666,11 +1711,25 @@ static int smsc_ircc_resume(struct device *dev)
         struct smsc_ircc_cb *self = dev_get_drvdata(dev);
 
         if (self->io.suspended) {
-
-                smsc_ircc_net_open(self->netdev);
+                IRDA_DEBUG(1, "%s, Waking up\n", driver_name);
+
+                rtnl_lock();
+                smsc_ircc_init_chip(self);
+                if (netif_running(self->netdev)) {
+                        if (smsc_ircc_request_irq(self)) {
+                                /*
+                                 * Don't fail resume process, just kill this
+                                 * network interface
+                                 */
+                                unregister_netdevice(self->netdev);
+                        } else {
+                                enable_dma(self->io.dma);
+                                smsc_ircc_start_interrupts(self);
+                                netif_device_attach(self->netdev);
+                        }
+                }
                 self->io.suspended = 0;
-
-                IRDA_MESSAGE("%s, Waking up\n", driver_name);
+                rtnl_unlock();
         }
         return 0;
 }
@@ -1683,9 +1742,6 @@ static int smsc_ircc_resume(struct device *dev)
  */
 static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
 {
-        int iobase;
-        unsigned long flags;
-
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
         IRDA_ASSERT(self != NULL, return -1;);
@@ -1695,22 +1751,7 @@ static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
         /* Remove netdevice */
         unregister_netdev(self->netdev);
 
-        /* Make sure the irq handler is not exectuting */
-        spin_lock_irqsave(&self->lock, flags);
-
-        /* Stop interrupts */
-        iobase = self->io.fir_base;
-        register_bank(iobase, 0);
-        outb(0, iobase + IRCC_IER);
-        outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
-        outb(0x00, iobase + IRCC_MASTER);
-#if 0
-        /* Reset to SIR mode */
-        register_bank(iobase, 1);
-        outb(IRCC_CFGA_IRDA_SIR_A|IRCC_CFGA_TX_POLARITY, iobase + IRCC_SCE_CFGA);
-        outb(IRCC_CFGB_IR, iobase + IRCC_SCE_CFGB);
-#endif
-        spin_unlock_irqrestore(&self->lock, flags);
+        smsc_ircc_stop_interrupts(self);
 
         /* Release the PORTS that this driver is using */
         IRDA_DEBUG(0, "%s(), releasing 0x%03x\n",  __FUNCTION__,
diff --git a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c
index 651c5a6578fd..a9f49f058cfb 100644
--- a/drivers/net/irda/vlsi_ir.c
+++ b/drivers/net/irda/vlsi_ir.c
@@ -473,8 +473,7 @@ static int vlsi_free_ring(struct vlsi_ring *r)
                 rd_set_addr_status(rd, 0, 0);
                 if (busaddr)
                         pci_unmap_single(r->pdev, busaddr, r->len, r->dir);
-                if (rd->buf)
-                        kfree(rd->buf);
+                kfree(rd->buf);
         }
         kfree(r);
         return 0;
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index 3d56cf5a4e23..f5ea39ff1017 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -70,8 +70,9 @@
 #include <linux/delay.h>
 #include <linux/mm.h>
 #include <linux/ethtool.h>
+
+#include <asm/abs_addr.h>
 #include <asm/iSeries/mf.h>
-#include <asm/iSeries/iSeries_pci.h>
 #include <asm/uaccess.h>
 
 #include <asm/iSeries/HvLpConfig.h>
@@ -1397,13 +1398,13 @@ static inline void veth_build_dma_list(struct dma_chunk *list,
          * it just at the granularity of iSeries real->absolute
          * mapping?  Indeed, given the way the allocator works, can we
          * count on them being absolutely contiguous? */
-        list[0].addr = ISERIES_HV_ADDR(p);
+        list[0].addr = iseries_hv_addr(p);
         list[0].size = min(length,
                            PAGE_SIZE - ((unsigned long)p & ~PAGE_MASK));
 
         done = list[0].size;
         while (done < length) {
-                list[i].addr = ISERIES_HV_ADDR(p + done);
+                list[i].addr = iseries_hv_addr(p + done);
                 list[i].size = min(length-done, PAGE_SIZE);
                 done += list[i].size;
                 i++;
@@ -1496,8 +1497,8 @@ static void veth_receive(struct veth_lpar_connection *cnx,
                                             cnx->dst_inst,
                                             HvLpDma_AddressType_RealAddress,
                                             HvLpDma_AddressType_TceIndex,
-                                            ISERIES_HV_ADDR(&local_list),
-                                            ISERIES_HV_ADDR(&remote_list),
+                                            iseries_hv_addr(&local_list),
+                                            iseries_hv_addr(&remote_list),
                                             length);
                 if (rc != HvLpDma_Rc_Good) {
                         dev_kfree_skb_irq(skb);
@@ -1647,10 +1648,13 @@ static struct vio_device_id veth_device_table[] __devinitdata = {
 MODULE_DEVICE_TABLE(vio, veth_device_table);
 
 static struct vio_driver veth_driver = {
-        .name = DRV_NAME,
         .id_table = veth_device_table,
         .probe = veth_probe,
-        .remove = veth_remove
+        .remove = veth_remove,
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+        }
 };
 
 /*
diff --git a/drivers/net/mace.c b/drivers/net/mace.c
index 81d0a26e4f41..2a5add257b8f 100644
--- a/drivers/net/mace.c
+++ b/drivers/net/mace.c
@@ -1016,6 +1016,7 @@ static struct of_device_id mace_match[] =
         },
         {},
 };
+MODULE_DEVICE_TABLE (of, mace_match);
 
 static struct macio_driver mace_driver = 
 {
@@ -1035,10 +1036,8 @@ static void __exit mace_cleanup(void)
 {
         macio_unregister_driver(&mace_driver);
 
-        if (dummy_buf) {
-                kfree(dummy_buf);
-                dummy_buf = NULL;
-        }
+        kfree(dummy_buf);
+        dummy_buf = NULL;
 }
 
 MODULE_AUTHOR("Paul Mackerras");
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 6fe948c10e72..71f2c6705bc3 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -1535,6 +1535,9 @@ static int mv643xx_eth_probe(struct device *ddev)
         printk(KERN_NOTICE "%s: RX NAPI Enabled \n", dev->name);
 #endif
 
+        if (mp->tx_sram_size > 0)
+                printk(KERN_NOTICE "%s: Using SRAM\n", dev->name);
+
         return 0;
 
 out:
diff --git a/drivers/net/ne2k-pci.c b/drivers/net/ne2k-pci.c
index e531a4eedfee..d11821dd86ed 100644
--- a/drivers/net/ne2k-pci.c
+++ b/drivers/net/ne2k-pci.c
@@ -675,7 +675,6 @@ static int ne2k_pci_resume (struct pci_dev *pdev)
         pci_set_power_state(pdev, 0);
         pci_restore_state(pdev);
         pci_enable_device(pdev);
-        pci_set_master(pdev);
         NS8390_init(dev, 1);
         netif_device_attach(dev);
 
diff --git a/drivers/net/ni65.c b/drivers/net/ni65.c
index 925d1dfcc4dc..bb42ff218484 100644
--- a/drivers/net/ni65.c
+++ b/drivers/net/ni65.c
@@ -696,8 +696,7 @@ static void ni65_free_buffer(struct priv *p)
                 return;
 
         for(i=0;i<TMDNUM;i++) {
-                if(p->tmdbounce[i])
-                        kfree(p->tmdbounce[i]);
+                kfree(p->tmdbounce[i]);
 #ifdef XMT_VIA_SKB
                 if(p->tmd_skb[i])
                         dev_kfree_skb(p->tmd_skb[i]);
@@ -710,12 +709,10 @@ static void ni65_free_buffer(struct priv *p)
                 if(p->recv_skb[i])
                         dev_kfree_skb(p->recv_skb[i]);
 #else
-                if(p->recvbounce[i])
-                        kfree(p->recvbounce[i]);
+                kfree(p->recvbounce[i]);
 #endif
         }
-        if(p->self)
-                kfree(p->self);
+        kfree(p->self);
 }
 
 
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index 9f22d138e3ad..818c185d6438 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1020,6 +1020,12 @@ static void set_misc_reg(struct net_device *dev)
         } else {
             outb(full_duplex ? 4 : 0, nic_base + DLINK_DIAG);
         }
+    } else if (info->flags & IS_DL10019) {
+        /* Advertise 100F, 100H, 10F, 10H */
+        mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 4, 0x01e1);
+        /* Restart MII autonegotiation */
+        mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
+        mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
     }
 }
 
diff --git a/drivers/net/rrunner.c b/drivers/net/rrunner.c
index ec1a18d189a1..19c2df9c86fe 100644
--- a/drivers/net/rrunner.c
+++ b/drivers/net/rrunner.c
@@ -1710,10 +1710,8 @@ static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                         error = -EFAULT;
                 }
         wf_out:
-                if (oldimage)
-                        kfree(oldimage);
-                if (image)
-                        kfree(image);
+                kfree(oldimage);
+                kfree(image);
                 return error;
                 
         case SIOCRRID:
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index d303d162974f..3f5e93aad5c7 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -705,8 +705,7 @@ static void free_shared_mem(struct s2io_nic *nic)
                         }
                         kfree(mac_control->rings[i].ba[j]);
                 }
-                if (mac_control->rings[i].ba)
-                        kfree(mac_control->rings[i].ba);
+                kfree(mac_control->rings[i].ba);
         }
 #endif
 
@@ -3045,7 +3044,7 @@ int s2io_set_swapper(nic_t * sp)
 
 int wait_for_msix_trans(nic_t *nic, int i)
 {
-        XENA_dev_config_t *bar0 = (XENA_dev_config_t *) nic->bar0;
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
         u64 val64;
         int ret = 0, cnt = 0;
 
@@ -3066,7 +3065,7 @@ int wait_for_msix_trans(nic_t *nic, int i)
 
 void restore_xmsi_data(nic_t *nic)
 {
-        XENA_dev_config_t *bar0 = (XENA_dev_config_t *) nic->bar0;
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
         u64 val64;
         int i;
 
@@ -3084,7 +3083,7 @@ void restore_xmsi_data(nic_t *nic)
 
 void store_xmsi_data(nic_t *nic)
 {
-        XENA_dev_config_t *bar0 = (XENA_dev_config_t *) nic->bar0;
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
         u64 val64, addr, data;
         int i;
 
@@ -3107,7 +3106,7 @@ void store_xmsi_data(nic_t *nic)
 
 int s2io_enable_msi(nic_t *nic)
 {
-        XENA_dev_config_t *bar0 = (XENA_dev_config_t *) nic->bar0;
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
         u16 msi_ctrl, msg_val;
         struct config_param *config = &nic->config;
         struct net_device *dev = nic->dev;
@@ -3157,7 +3156,7 @@ int s2io_enable_msi(nic_t *nic)
 
 int s2io_enable_msi_x(nic_t *nic)
 {
-        XENA_dev_config_t *bar0 = (XENA_dev_config_t *) nic->bar0;
+        XENA_dev_config_t __iomem *bar0 = nic->bar0;
         u64 tx_mat, rx_mat;
         u16 msi_control; /* Temp variable */
         int ret, i, j, msix_indx = 1;
diff --git a/drivers/net/saa9730.c b/drivers/net/saa9730.c
index fd0167077fbe..110e777f206e 100644
--- a/drivers/net/saa9730.c
+++ b/drivers/net/saa9730.c
@@ -997,10 +997,7 @@ static void __devexit saa9730_remove_one(struct pci_dev *pdev)
 
         if (dev) {
                 unregister_netdev(dev);
-
-                if (dev->priv)
-                        kfree(dev->priv);
-
+                kfree(dev->priv);
                 free_netdev(dev);
                 pci_release_regions(pdev);
                 pci_disable_device(pdev);
@@ -1096,8 +1093,7 @@ static int lan_saa9730_init(struct net_device *dev, int ioaddr, int irq)
         return 0;
 
  out:
-        if (dev->priv)
-                kfree(dev->priv);
+        kfree(dev->priv);
         return ret;
 }
 
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index 92f75529eff8..478791e09bf7 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -842,7 +842,7 @@ static void sis190_set_rx_mode(struct net_device *dev)
                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
                      i++, mclist = mclist->next) {
                         int bit_nr =
-                                ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
+                                ether_crc(ETH_ALEN, mclist->dmi_addr) & 0x3f;
                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
                         rx_mode |= AcceptMulticast;
                 }
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 23b713c700b3..1d4d88680db1 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -1696,15 +1696,20 @@ static int sis900_rx(struct net_device *net_dev)
         long ioaddr = net_dev->base_addr;
         unsigned int entry = sis_priv->cur_rx % NUM_RX_DESC;
         u32 rx_status = sis_priv->rx_ring[entry].cmdsts;
+        int rx_work_limit;
 
         if (netif_msg_rx_status(sis_priv))
                 printk(KERN_DEBUG "sis900_rx, cur_rx:%4.4d, dirty_rx:%4.4d "
                        "status:0x%8.8x\n",
                        sis_priv->cur_rx, sis_priv->dirty_rx, rx_status);
+        rx_work_limit = sis_priv->dirty_rx + NUM_RX_DESC - sis_priv->cur_rx;
 
         while (rx_status & OWN) {
                 unsigned int rx_size;
 
+                if (--rx_work_limit < 0)
+                        break;
+
                 rx_size = (rx_status & DSIZE) - CRC_SIZE;
 
                 if (rx_status & (ABORT|OVERRUN|TOOLONG|RUNT|RXISERR|CRCERR|FAERR)) {
@@ -1732,9 +1737,11 @@ static int sis900_rx(struct net_device *net_dev)
                            we are working on NULL sk_buff :-( */
                         if (sis_priv->rx_skbuff[entry] == NULL) {
                                 if (netif_msg_rx_err(sis_priv))
-                                        printk(KERN_INFO "%s: NULL pointer " 
-                                                "encountered in Rx ring, skipping\n",
-                                                net_dev->name);
+                                        printk(KERN_WARNING "%s: NULL pointer " 
+                                              "encountered in Rx ring\n"
+                                              "cur_rx:%4.4d, dirty_rx:%4.4d\n",
+                                              net_dev->name, sis_priv->cur_rx,
+                                              sis_priv->dirty_rx);
                                 break;
                         }
 
@@ -1770,6 +1777,7 @@ static int sis900_rx(struct net_device *net_dev)
                                 sis_priv->rx_ring[entry].cmdsts = 0;
                                 sis_priv->rx_ring[entry].bufptr = 0;
                                 sis_priv->stats.rx_dropped++;
+                                sis_priv->cur_rx++;
                                 break;
                         }
                         skb->dev = net_dev;
@@ -1787,7 +1795,7 @@ static int sis900_rx(struct net_device *net_dev)
 
         /* refill the Rx buffer, what if the rate of refilling is slower
          * than consuming ?? */
-        for (;sis_priv->cur_rx - sis_priv->dirty_rx > 0; sis_priv->dirty_rx++) {
+        for (; sis_priv->cur_rx != sis_priv->dirty_rx; sis_priv->dirty_rx++) {
                 struct sk_buff *skb;
 
                 entry = sis_priv->dirty_rx % NUM_RX_DESC;
diff --git a/drivers/net/skfp/smt.c b/drivers/net/skfp/smt.c
index f17c05cbe44b..99a776a51fb5 100644
--- a/drivers/net/skfp/smt.c
+++ b/drivers/net/skfp/smt.c
@@ -1896,7 +1896,7 @@ void smt_swap_para(struct smt_header *sm, int len, int direction)
 
 static void smt_string_swap(char *data, const char *format, int len)
 {
-        const char      *open_paren = 0 ;
+        const char      *open_paren = NULL ;
         int     x ;
 
         while (len > 0  && *format) {
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index 901c960d342a..74d5f1a6fdea 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -1983,6 +1983,10 @@ static int __init smc_probe(struct net_device *dev, void __iomem *ioaddr)
         if (lp->version >= (CHIP_91100 << 4))
                 smc_phy_detect(dev);
 
+        /* then shut everything down to save power */
+        smc_shutdown(dev);
+        smc_phy_powerdown(dev);
+
         /* Set default parameters */
         lp->msg_enable = NETIF_MSG_LINK;
         lp->ctl_rfduplx = 0;
diff --git a/drivers/net/smc91x.h b/drivers/net/smc91x.h
index ac9ce6509eee..817f200742c3 100644
--- a/drivers/net/smc91x.h
+++ b/drivers/net/smc91x.h
@@ -230,12 +230,12 @@ SMC_outw(u16 val, void __iomem *ioaddr, int reg)
 #define SMC_CAN_USE_16BIT       1
 #define SMC_CAN_USE_32BIT       0
 
-#define SMC_inb(a, r)           inb((a) + (r) - 0xa0000000)
-#define SMC_inw(a, r)           inw((a) + (r) - 0xa0000000)
-#define SMC_outb(v, a, r)       outb(v, (a) + (r) - 0xa0000000)
-#define SMC_outw(v, a, r)       outw(v, (a) + (r) - 0xa0000000)
-#define SMC_insw(a, r, p, l)    insw((a) + (r) - 0xa0000000, p, l)
-#define SMC_outsw(a, r, p, l)   outsw((a) + (r) - 0xa0000000, p, l)
+#define SMC_inb(a, r)           inb((u32)a) + (r))
+#define SMC_inw(a, r)           inw(((u32)a) + (r))
+#define SMC_outb(v, a, r)       outb(v, ((u32)a) + (r))
+#define SMC_outw(v, a, r)       outw(v, ((u32)a) + (r))
+#define SMC_insw(a, r, p, l)    insw(((u32)a) + (r), p, l)
+#define SMC_outsw(a, r, p, l)   outsw(((u32)a) + (r), p, l)
 
 #define set_irq_type(irq, type) do {} while(0)
 
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index efdb179ecc8c..38b2b0a3ce96 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -1091,8 +1091,10 @@ static int netdev_open(struct net_device *dev)
                 rx_ring_size = sizeof(struct starfire_rx_desc) * RX_RING_SIZE;
                 np->queue_mem_size = tx_done_q_size + rx_done_q_size + tx_ring_size + rx_ring_size;
                 np->queue_mem = pci_alloc_consistent(np->pci_dev, np->queue_mem_size, &np->queue_mem_dma);
-                if (np->queue_mem == 0)
+                if (np->queue_mem == NULL) {
+                        free_irq(dev->irq, dev);
                         return -ENOMEM;
+                }
 
                 np->tx_done_q     = np->queue_mem;
                 np->tx_done_q_dma = np->queue_mem_dma;
diff --git a/drivers/net/sundance.c b/drivers/net/sundance.c
index 5de0554fd7c6..0ab9c38b4a34 100644
--- a/drivers/net/sundance.c
+++ b/drivers/net/sundance.c
@@ -80,7 +80,7 @@
           I/O access could affect performance in ARM-based system
         - Add Linux software VLAN support
         
-        Version LK1.08 (D-Link):
+        Version LK1.08 (Philippe De Muyter phdm@macqel.be):
         - Fix bug of custom mac address 
         (StationAddr register only accept word write) 
 
@@ -91,11 +91,14 @@
         Version LK1.09a (ICPlus):
         - Add the delay time in reading the contents of EEPROM
 
+        Version LK1.10 (Philippe De Muyter phdm@macqel.be):
+        - Make 'unblock interface after Tx underrun' work
+
 */
 
 #define DRV_NAME        "sundance"
-#define DRV_VERSION     "1.01+LK1.09a"
-#define DRV_RELDATE     "10-Jul-2003"
+#define DRV_VERSION     "1.01+LK1.10"
+#define DRV_RELDATE     "28-Oct-2005"
 
 
 /* The user-configurable values.
@@ -263,8 +266,10 @@ IV. Notes
 IVb. References
 
 The Sundance ST201 datasheet, preliminary version.
-http://cesdis.gsfc.nasa.gov/linux/misc/100mbps.html
-http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
+The Kendin KS8723 datasheet, preliminary version.
+The ICplus IP100 datasheet, preliminary version.
+http://www.scyld.com/expert/100mbps.html
+http://www.scyld.com/expert/NWay.html
 
 IVc. Errata
 
@@ -500,6 +505,25 @@ static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 static int  netdev_close(struct net_device *dev);
 static struct ethtool_ops ethtool_ops;
 
+static void sundance_reset(struct net_device *dev, unsigned long reset_cmd)
+{
+        struct netdev_private *np = netdev_priv(dev);
+        void __iomem *ioaddr = np->base + ASICCtrl;
+        int countdown;
+
+        /* ST201 documentation states ASICCtrl is a 32bit register */
+        iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);
+        /* ST201 documentation states reset can take up to 1 ms */
+        countdown = 10 + 1;
+        while (ioread32 (ioaddr) & (ResetBusy << 16)) {
+                if (--countdown == 0) {
+                        printk(KERN_WARNING "%s : reset not completed !!\n", dev->name);
+                        break;
+                }
+                udelay(100);
+        }
+}
+
 static int __devinit sundance_probe1 (struct pci_dev *pdev,
                                       const struct pci_device_id *ent)
 {
@@ -1190,23 +1214,33 @@ static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *rgs
                                             ("%s: Transmit status is %2.2x.\n",
                                         dev->name, tx_status);
                                 if (tx_status & 0x1e) {
+                                        if (netif_msg_tx_err(np))
+                                                printk("%s: Transmit error status %4.4x.\n",
+                                                           dev->name, tx_status);
                                         np->stats.tx_errors++;
                                         if (tx_status & 0x10)
                                                 np->stats.tx_fifo_errors++;
                                         if (tx_status & 0x08)
                                                 np->stats.collisions++;
+                                        if (tx_status & 0x04)
+                                                np->stats.tx_fifo_errors++;
                                         if (tx_status & 0x02)
                                                 np->stats.tx_window_errors++;
-                                        /* This reset has not been verified!. */
-                                        if (tx_status & 0x10) { /* Reset the Tx. */
-                                                np->stats.tx_fifo_errors++;
-                                                spin_lock(&np->lock);
-                                                reset_tx(dev);
-                                                spin_unlock(&np->lock);
+                                        /*
+                                        ** This reset has been verified on
+                                        ** DFE-580TX boards ! phdm@macqel.be.
+                                        */
+                                        if (tx_status & 0x10) { /* TxUnderrun */
+                                                unsigned short txthreshold;
+
+                                                txthreshold = ioread16 (ioaddr + TxStartThresh);
+                                                /* Restart Tx FIFO and transmitter */
+                                                sundance_reset(dev, (NetworkReset|FIFOReset|TxReset) << 16);
+                                                iowrite16 (txthreshold, ioaddr + TxStartThresh);
+                                                /* No need to reset the Tx pointer here */
                                         }
-                                        if (tx_status & 0x1e)   /* Restart the Tx. */
-                                                iowrite16 (TxEnable,
-                                                        ioaddr + MACCtrl1);
+                                        /* Restart the Tx. */
+                                        iowrite16 (TxEnable, ioaddr + MACCtrl1);
                                 }
                                 /* Yup, this is a documentation bug.  It cost me *hours*. */
                                 iowrite16 (0, ioaddr + TxStatus);
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 1802c3b48799..1828a6bf8458 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -37,6 +37,7 @@
 #include <linux/tcp.h>
 #include <linux/workqueue.h>
 #include <linux/prefetch.h>
+#include <linux/dma-mapping.h>
 
 #include <net/checksum.h>
 
@@ -67,8 +68,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.42"
-#define DRV_MODULE_RELDATE      "Oct 3, 2005"
+#define DRV_MODULE_VERSION      "3.43"
+#define DRV_MODULE_RELDATE      "Oct 24, 2005"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -219,6 +220,10 @@ static struct pci_device_id tg3_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753F,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S,
@@ -466,6 +471,15 @@ static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
         spin_unlock_irqrestore(&tp->indirect_lock, flags);
 }
 
+static void tg3_write_mem_fast(struct tg3 *tp, u32 off, u32 val)
+{
+        /* If no workaround is needed, write to mem space directly */
+        if (tp->write32 != tg3_write_indirect_reg32)
+                tw32(NIC_SRAM_WIN_BASE + off, val);
+        else
+                tg3_write_mem(tp, off, val);
+}
+
 static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
 {
         unsigned long flags;
@@ -570,7 +584,7 @@ static void tg3_switch_clocks(struct tg3 *tp)
         u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL);
         u32 orig_clock_ctrl;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                 return;
 
         orig_clock_ctrl = clock_ctrl;
@@ -1210,7 +1224,7 @@ static int tg3_set_power_state(struct tg3 *tp, int state)
                      CLOCK_CTRL_ALTCLK |
                      CLOCK_CTRL_PWRDOWN_PLL133);
                 udelay(40);
-        } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+        } else if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                 /* do nothing */
         } else if (!((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
                      (tp->tg3_flags & TG3_FLAG_ENABLE_ASF))) {
@@ -3712,14 +3726,14 @@ static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
         dev->mtu = new_mtu;
 
         if (new_mtu > ETH_DATA_LEN) {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+                if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                         tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
                         ethtool_op_set_tso(dev, 0);
                 }
                 else
                         tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
         } else {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+                if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                         tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
                 tp->tg3_flags &= ~TG3_FLAG_JUMBO_RING_ENABLE;
         }
@@ -3850,7 +3864,7 @@ static void tg3_init_rings(struct tg3 *tp)
         memset(tp->tx_ring, 0, TG3_TX_RING_BYTES);
 
         tp->rx_pkt_buf_sz = RX_PKT_BUF_SZ;
-        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) &&
+        if ((tp->tg3_flags2 & TG3_FLG2_5780_CLASS) &&
             (tp->dev->mtu > ETH_DATA_LEN))
                 tp->rx_pkt_buf_sz = RX_JUMBO_PKT_BUF_SZ;
 
@@ -3905,10 +3919,8 @@ static void tg3_init_rings(struct tg3 *tp)
  */
 static void tg3_free_consistent(struct tg3 *tp)
 {
-        if (tp->rx_std_buffers) {
-                kfree(tp->rx_std_buffers);
-                tp->rx_std_buffers = NULL;
-        }
+        kfree(tp->rx_std_buffers);
+        tp->rx_std_buffers = NULL;
         if (tp->rx_std) {
                 pci_free_consistent(tp->pdev, TG3_RX_RING_BYTES,
                                     tp->rx_std, tp->rx_std_mapping);
@@ -4347,7 +4359,7 @@ static int tg3_chip_reset(struct tg3 *tp)
         val &= ~PCIX_CAPS_RELAXED_ORDERING;
         pci_write_config_dword(tp->pdev, TG3PCI_X_CAPS, val);
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                 u32 val;
 
                 /* Chip reset on 5780 will reset MSI enable bit,
@@ -6003,7 +6015,7 @@ static int tg3_reset_hw(struct tg3 *tp)
         tw32(MAC_RCV_VALUE_1, 0xffffffff & RCV_RULE_DISABLE_MASK);
 
         if ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
-            (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5780))
+            !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 limit = 8;
         else
                 limit = 16;
@@ -6191,14 +6203,16 @@ static void tg3_timer(unsigned long __opaque)
                 tp->timer_counter = tp->timer_multiplier;
         }
 
-        /* Heartbeat is only sent once every 120 seconds.  */
+        /* Heartbeat is only sent once every 2 seconds.  */
         if (!--tp->asf_counter) {
                 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
                         u32 val;
 
-                        tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_ALIVE);
-                        tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
-                        tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 3);
+                        tg3_write_mem_fast(tp, NIC_SRAM_FW_CMD_MBOX,
+                                           FWCMD_NICDRV_ALIVE2);
+                        tg3_write_mem_fast(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
+                        /* 5 seconds timeout */
+                        tg3_write_mem_fast(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 5);
                         val = tr32(GRC_RX_CPU_EVENT);
                         val |= (1 << 14);
                         tw32(GRC_RX_CPU_EVENT, val);
@@ -6409,7 +6423,7 @@ static int tg3_open(struct net_device *dev)
                 tp->timer_counter = tp->timer_multiplier =
                         (HZ / tp->timer_offset);
                 tp->asf_counter = tp->asf_multiplier =
-                        ((HZ / tp->timer_offset) * 120);
+                        ((HZ / tp->timer_offset) * 2);
 
                 init_timer(&tp->timer);
                 tp->timer.expires = jiffies + tp->timer_offset;
@@ -7237,7 +7251,7 @@ static int tg3_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 cmd->supported |= (SUPPORTED_1000baseT_Half |
                                    SUPPORTED_1000baseT_Full);
 
-        if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES))
+        if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
                 cmd->supported |= (SUPPORTED_100baseT_Half |
                                   SUPPORTED_100baseT_Full |
                                   SUPPORTED_10baseT_Half |
@@ -7264,7 +7278,7 @@ static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
         struct tg3 *tp = netdev_priv(dev);
   
-        if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
+        if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) { 
                 /* These are the only valid advertisement bits allowed.  */
                 if (cmd->autoneg == AUTONEG_ENABLE &&
                     (cmd->advertising & ~(ADVERTISED_1000baseT_Half |
@@ -7272,7 +7286,17 @@ static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                                           ADVERTISED_Autoneg |
                                           ADVERTISED_FIBRE)))
                         return -EINVAL;
-        }
+                /* Fiber can only do SPEED_1000.  */
+                else if ((cmd->autoneg != AUTONEG_ENABLE) &&
+                         (cmd->speed != SPEED_1000))
+                        return -EINVAL;
+        /* Copper cannot force SPEED_1000.  */
+        } else if ((cmd->autoneg != AUTONEG_ENABLE) &&
+                   (cmd->speed == SPEED_1000))
+                return -EINVAL;
+        else if ((cmd->speed == SPEED_1000) &&
+                 (tp->tg3_flags2 & TG3_FLAG_10_100_ONLY))
+                return -EINVAL;
 
         tg3_full_lock(tp, 0);
 
@@ -8380,7 +8404,7 @@ static void __devinit tg3_get_nvram_info(struct tg3 *tp)
         }
 
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) ||
-            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)) {
+            (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
                 switch (nvcfg1 & NVRAM_CFG1_VENDOR_MASK) {
                         case FLASH_VENDOR_ATMEL_FLASH_BUFFERED:
                                 tp->nvram_jedecnum = JEDEC_ATMEL;
@@ -8980,7 +9004,7 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
 
                 tp->phy_id = eeprom_phy_id;
                 if (eeprom_phy_serdes) {
-                        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+                        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                                 tp->tg3_flags2 |= TG3_FLG2_MII_SERDES;
                         else
                                 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
@@ -9393,8 +9417,11 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         }
 
         /* Find msi capability. */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
+                tp->tg3_flags2 |= TG3_FLG2_5780_CLASS;
                 tp->msi_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_MSI);
+        }
 
         /* Initialize misc host control in PCI block. */
         tp->misc_host_ctrl |= (misc_ctrl_reg &
@@ -9412,7 +9439,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
+            (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
 
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) ||
@@ -9607,7 +9634,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
          * ether_setup() via the alloc_etherdev() call
          */
         if (tp->dev->mtu > ETH_DATA_LEN &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5780)
+            !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
 
         /* Determine WakeOnLan speed to use. */
@@ -9830,7 +9857,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
         mac_offset = 0x7c;
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
              !(tp->tg3_flags & TG3_FLG2_SUN_570X)) ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
+            (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
                         mac_offset = 0xcc;
                 if (tg3_nvram_lock(tp))
@@ -10148,6 +10175,9 @@ static int __devinit tg3_test_dma(struct tg3 *tp)
                 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
                         /* 5780 always in PCIX mode */
                         tp->dma_rwctrl |= 0x00144000;
+                } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
+                        /* 5714 always in PCIX mode */
+                        tp->dma_rwctrl |= 0x00148000;
                 } else {
                         tp->dma_rwctrl |= 0x001b000f;
                 }
@@ -10347,6 +10377,7 @@ static char * __devinit tg3_phy_string(struct tg3 *tp)
         case PHY_ID_BCM5705:    return "5705";
         case PHY_ID_BCM5750:    return "5750";
         case PHY_ID_BCM5752:    return "5752";
+        case PHY_ID_BCM5714:    return "5714";
         case PHY_ID_BCM5780:    return "5780";
         case PHY_ID_BCM8002:    return "8002/serdes";
         case 0:                 return "serdes";
@@ -10492,17 +10523,17 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         }
 
         /* Configure DMA attributes. */
-        err = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+        err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
         if (!err) {
                 pci_using_dac = 1;
-                err = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL);
+                err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
                 if (err < 0) {
                         printk(KERN_ERR PFX "Unable to obtain 64 bit DMA "
                                "for consistent allocations\n");
                         goto err_out_free_res;
                 }
         } else {
-                err = pci_set_dma_mask(pdev, 0xffffffffULL);
+                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (err) {
                         printk(KERN_ERR PFX "No usable DMA configuration, "
                                "aborting.\n");
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 2e733c60bfa4..fb7e2a5f4a08 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -137,6 +137,7 @@
 #define   ASIC_REV_5750                  0x04
 #define   ASIC_REV_5752                  0x06
 #define   ASIC_REV_5780                  0x08
+#define   ASIC_REV_5714                  0x09
 #define  GET_CHIP_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 8)
 #define   CHIPREV_5700_AX                0x70
 #define   CHIPREV_5700_BX                0x71
@@ -531,6 +532,8 @@
 #define  MAC_SERDES_CFG_EDGE_SELECT      0x00001000
 #define MAC_SERDES_STAT                 0x00000594
 /* 0x598 --> 0x5b0 unused */
+#define SERDES_RX_CTRL                  0x000005b0      /* 5780/5714 only */
+#define  SERDES_RX_SIG_DETECT            0x00000400
 #define SG_DIG_CTRL                     0x000005b0
 #define  SG_DIG_USING_HW_AUTONEG         0x80000000
 #define  SG_DIG_SOFT_RESET               0x40000000
@@ -1329,6 +1332,8 @@
 #define  GRC_LCLCTRL_CLEARINT           0x00000002
 #define  GRC_LCLCTRL_SETINT             0x00000004
 #define  GRC_LCLCTRL_INT_ON_ATTN        0x00000008
+#define  GRC_LCLCTRL_USE_SIG_DETECT     0x00000010      /* 5714/5780 only */
+#define  GRC_LCLCTRL_USE_EXT_SIG_DETECT 0x00000020      /* 5714/5780 only */
 #define  GRC_LCLCTRL_GPIO_INPUT3        0x00000020
 #define  GRC_LCLCTRL_GPIO_OE3           0x00000040
 #define  GRC_LCLCTRL_GPIO_OUTPUT3       0x00000080
@@ -1507,6 +1512,7 @@
 #define  FWCMD_NICDRV_IPV6ADDR_CHG       0x00000004
 #define  FWCMD_NICDRV_FIX_DMAR           0x00000005
 #define  FWCMD_NICDRV_FIX_DMAW           0x00000006
+#define  FWCMD_NICDRV_ALIVE2             0x0000000d
 #define NIC_SRAM_FW_CMD_LEN_MBOX        0x00000b7c
 #define NIC_SRAM_FW_CMD_DATA_MBOX       0x00000b80
 #define NIC_SRAM_FW_ASF_STATUS_MBOX     0x00000c00
@@ -2175,6 +2181,7 @@ struct tg3 {
                                         TG3_FLG2_MII_SERDES)
 #define TG3_FLG2_PARALLEL_DETECT        0x01000000
 #define TG3_FLG2_ICH_WORKAROUND         0x02000000
+#define TG3_FLG2_5780_CLASS             0x04000000
 
         u32                             split_mode_max_reqs;
 #define SPLIT_MODE_5704_MAX_REQ         3
@@ -2222,6 +2229,7 @@ struct tg3 {
 #define PHY_ID_BCM5705                  0x600081a0
 #define PHY_ID_BCM5750                  0x60008180
 #define PHY_ID_BCM5752                  0x60008100
+#define PHY_ID_BCM5714                  0x60008340
 #define PHY_ID_BCM5780                  0x60008350
 #define PHY_ID_BCM8002                  0x60010140
 #define PHY_ID_INVALID                  0xffffffff
@@ -2246,8 +2254,8 @@ struct tg3 {
          (X) == PHY_ID_BCM5411 || (X) == PHY_ID_BCM5701 || \
          (X) == PHY_ID_BCM5703 || (X) == PHY_ID_BCM5704 || \
          (X) == PHY_ID_BCM5705 || (X) == PHY_ID_BCM5750 || \
-         (X) == PHY_ID_BCM5752 || (X) == PHY_ID_BCM5780 || \
-         (X) == PHY_ID_BCM8002)
+         (X) == PHY_ID_BCM5752 || (X) == PHY_ID_BCM5714 || \
+         (X) == PHY_ID_BCM5780 || (X) == PHY_ID_BCM8002)
 
         struct tg3_hw_stats             *hw_stats;
         dma_addr_t                      stats_mapping;
diff --git a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
index 6b8eee8f7bfd..d7fb3ffe06ac 100644
--- a/drivers/net/tulip/de2104x.c
+++ b/drivers/net/tulip/de2104x.c
@@ -2076,8 +2076,7 @@ static int __init de_init_one (struct pci_dev *pdev,
         return 0;
 
 err_out_iomap:
-        if (de->ee_data)
-                kfree(de->ee_data);
+        kfree(de->ee_data);
         iounmap(regs);
 err_out_res:
         pci_release_regions(pdev);
@@ -2096,8 +2095,7 @@ static void __exit de_remove_one (struct pci_dev *pdev)
         if (!dev)
                 BUG();
         unregister_netdev(dev);
-        if (de->ee_data)
-                kfree(de->ee_data);
+        kfree(de->ee_data);
         iounmap(de->regs);
         pci_release_regions(pdev);
         pci_disable_device(pdev);
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index 6266a9a7e6e3..125ed00e95a5 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -1727,8 +1727,7 @@ err_out_free_ring:
                              tp->rx_ring, tp->rx_ring_dma);
 
 err_out_mtable:
-        if (tp->mtable)
-                kfree (tp->mtable);
+        kfree (tp->mtable);
         pci_iounmap(pdev, ioaddr);
 
 err_out_free_res:
@@ -1806,8 +1805,7 @@ static void __devexit tulip_remove_one (struct pci_dev *pdev)
                              sizeof (struct tulip_rx_desc) * RX_RING_SIZE +
                              sizeof (struct tulip_tx_desc) * TX_RING_SIZE,
                              tp->rx_ring, tp->rx_ring_dma);
-        if (tp->mtable)
-                kfree (tp->mtable);
+        kfree (tp->mtable);
         pci_iounmap(pdev, tp->base_addr);
         free_netdev (dev);
         pci_release_regions (pdev);
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index abc5cee6eedc..a368d08e7d19 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -1212,10 +1212,8 @@ static void velocity_free_td_ring(struct velocity_info *vptr)
                         velocity_free_td_ring_entry(vptr, j, i);
 
                 }
-                if (vptr->td_infos[j]) {
-                        kfree(vptr->td_infos[j]);
-                        vptr->td_infos[j] = NULL;
-                }
+                kfree(vptr->td_infos[j]);
+                vptr->td_infos[j] = NULL;
         }
 }
 
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index cb429e783749..750c0167539c 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -35,6 +35,7 @@
 #include <linux/interrupt.h>
 #include <linux/in.h>
 #include <linux/bitops.h>
+#include <linux/scatterlist.h>
 #include <asm/io.h>
 #include <asm/system.h>
 
@@ -1590,11 +1591,9 @@ static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct
                 aes_counter[12] = (u8)(counter >> 24);
                 counter++;
                 memcpy (plain, aes_counter, 16);
-                sg[0].page = virt_to_page(plain);
-                sg[0].offset = ((long) plain & ~PAGE_MASK);
-                sg[0].length = 16;
+                sg_set_buf(sg, plain, 16);
                 crypto_cipher_encrypt(tfm, sg, sg, 16);
-                cipher = kmap(sg[0].page) + sg[0].offset;
+                cipher = kmap(sg->page) + sg->offset;
                 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
                         context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
                         j += 4;
@@ -2381,14 +2380,10 @@ void stop_airo_card( struct net_device *dev, int freeres )
                         dev_kfree_skb(skb);
         }
 
-        if (ai->flash)
-                kfree(ai->flash);
-        if (ai->rssi)
-                kfree(ai->rssi);
-        if (ai->APList)
-                kfree(ai->APList);
-        if (ai->SSID)
-                kfree(ai->SSID);
+        kfree(ai->flash);
+        kfree(ai->rssi);
+        kfree(ai->APList);
+        kfree(ai->SSID);
         if (freeres) {
                 /* PCMCIA frees this stuff, so only for PCI and ISA */
                 release_region( dev->base_addr, 64 );
@@ -3626,10 +3621,8 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
         int rc;
 
         memset( &mySsid, 0, sizeof( mySsid ) );
-        if (ai->flash) {
-                kfree (ai->flash);
-                ai->flash = NULL;
-        }
+        kfree (ai->flash);
+        ai->flash = NULL;
 
         /* The NOP is the first step in getting the card going */
         cmd.cmd = NOP;
@@ -3666,14 +3659,10 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
                 tdsRssiRid rssi_rid;
                 CapabilityRid cap_rid;
 
-                if (ai->APList) {
-                        kfree(ai->APList);
-                        ai->APList = NULL;
-                }
-                if (ai->SSID) {
-                        kfree(ai->SSID);
-                        ai->SSID = NULL;
-                }
+                kfree(ai->APList);
+                ai->APList = NULL;
+                kfree(ai->SSID);
+                ai->SSID = NULL;
                 // general configuration (read/modify/write)
                 status = readConfigRid(ai, lock);
                 if ( status != SUCCESS ) return ERROR;
@@ -3687,10 +3676,8 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
                                 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
                 }
                 else {
-                        if (ai->rssi) {
-                                kfree(ai->rssi);
-                                ai->rssi = NULL;
-                        }
+                        kfree(ai->rssi);
+                        ai->rssi = NULL;
                         if (cap_rid.softCap & 8)
                                 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
                         else
@@ -5369,11 +5356,13 @@ static int proc_BSSList_open( struct inode *inode, struct file *file ) {
 
 static int proc_close( struct inode *inode, struct file *file )
 {
-        struct proc_data *data = (struct proc_data *)file->private_data;
-        if ( data->on_close != NULL ) data->on_close( inode, file );
-        if ( data->rbuffer ) kfree( data->rbuffer );
-        if ( data->wbuffer ) kfree( data->wbuffer );
-        kfree( data );
+        struct proc_data *data = file->private_data;
+
+        if (data->on_close != NULL)
+                data->on_close(inode, file);
+        kfree(data->rbuffer);
+        kfree(data->wbuffer);
+        kfree(data);
         return 0;
 }
 
diff --git a/drivers/net/wireless/airo_cs.c b/drivers/net/wireless/airo_cs.c
index bf25584d68d3..784de9109113 100644
--- a/drivers/net/wireless/airo_cs.c
+++ b/drivers/net/wireless/airo_cs.c
@@ -258,9 +258,7 @@ static void airo_detach(dev_link_t *link)
         
         /* Unlink device structure, free pieces */
         *linkp = link->next;
-        if (link->priv) {
-                kfree(link->priv);
-        }
+        kfree(link->priv);
         kfree(link);
         
 } /* airo_detach */
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index d57011028b72..1fbe027d26b6 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -1653,8 +1653,7 @@ void stop_atmel_card(struct net_device *dev, int freeres)
         unregister_netdev(dev);
         remove_proc_entry("driver/atmel", NULL);
         free_irq(dev->irq, dev);
-        if (priv->firmware)
-                kfree(priv->firmware);
+        kfree(priv->firmware);
         if (freeres) {
                 /* PCMCIA frees this stuff, so only for PCI */
                 release_region(dev->base_addr, 64);
@@ -2450,8 +2449,7 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                         break;
                 }
 
-                if (priv->firmware)
-                        kfree(priv->firmware);
+                kfree(priv->firmware);
                 
                 priv->firmware = new_firmware;
                 priv->firmware_length = com.len;
diff --git a/drivers/net/wireless/atmel_cs.c b/drivers/net/wireless/atmel_cs.c
index ff031a3985b3..195cb36619e8 100644
--- a/drivers/net/wireless/atmel_cs.c
+++ b/drivers/net/wireless/atmel_cs.c
@@ -259,8 +259,7 @@ static void atmel_detach(dev_link_t *link)
 
         /* Unlink device structure, free pieces */
         *linkp = link->next;
-        if (link->priv)
-                kfree(link->priv);
+        kfree(link->priv);
         kfree(link);
 }
 
diff --git a/drivers/net/wireless/hermes.c b/drivers/net/wireless/hermes.c
index eba0d9d2b7c5..579480dad374 100644
--- a/drivers/net/wireless/hermes.c
+++ b/drivers/net/wireless/hermes.c
@@ -444,6 +444,43 @@ int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, unsigned len,
         return err;
 }
 
+/* Write a block of data to the chip's buffer with padding if
+ * neccessary, via the BAP. Synchronization/serialization is the
+ * caller's problem. len must be even.
+ *
+ * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
+ */
+int hermes_bap_pwrite_pad(hermes_t *hw, int bap, const void *buf, unsigned data_len, unsigned len,
+                      u16 id, u16 offset)
+{
+        int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
+        int err = 0;
+
+        if (len < 0 || len % 2 || data_len > len)
+                return -EINVAL;
+
+        err = hermes_bap_seek(hw, bap, id, offset);
+        if (err)
+                goto out;
+
+        /* Transfer all the complete words of data */
+        hermes_write_words(hw, dreg, buf, data_len/2);
+        /* If there is an odd byte left over pad and transfer it */
+        if (data_len & 1) {
+                u8 end[2];
+                end[1] = 0;
+                end[0] = ((unsigned char *)buf)[data_len - 1];
+                hermes_write_words(hw, dreg, end, 1);
+                data_len ++;
+        }
+        /* Now send zeros for the padding */
+        if (data_len < len)
+                hermes_clear_words(hw, dreg, (len - data_len) / 2);
+        /* Complete */
+ out:
+        return err;
+}
+
 /* Read a Length-Type-Value record from the card.
  *
  * If length is NULL, we ignore the length read from the card, and
@@ -531,6 +568,7 @@ EXPORT_SYMBOL(hermes_allocate);
 
 EXPORT_SYMBOL(hermes_bap_pread);
 EXPORT_SYMBOL(hermes_bap_pwrite);
+EXPORT_SYMBOL(hermes_bap_pwrite_pad);
 EXPORT_SYMBOL(hermes_read_ltv);
 EXPORT_SYMBOL(hermes_write_ltv);
 
diff --git a/drivers/net/wireless/hermes.h b/drivers/net/wireless/hermes.h
index ad28e3294360..a6bd472d75d4 100644
--- a/drivers/net/wireless/hermes.h
+++ b/drivers/net/wireless/hermes.h
@@ -376,6 +376,8 @@ int hermes_bap_pread(hermes_t *hw, int bap, void *buf, unsigned len,
                        u16 id, u16 offset);
 int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, unsigned len,
                         u16 id, u16 offset);
+int hermes_bap_pwrite_pad(hermes_t *hw, int bap, const void *buf,
+                        unsigned data_len, unsigned len, u16 id, u16 offset);
 int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, unsigned buflen,
                     u16 *length, void *buf);
 int hermes_write_ltv(hermes_t *hw, int bap, u16 rid,
diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
index 53f5246c40aa..2617d70bcda9 100644
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
@@ -552,7 +552,6 @@ static int prism2_ioctl_giwaplist(struct net_device *dev,
 
         kfree(addr);
         kfree(qual);
-
         return 0;
 }
 
@@ -3081,9 +3080,7 @@ static int prism2_ioctl_priv_download(local_info_t *local, struct iw_point *p)
         ret = local->func->download(local, param);
 
  out:
-        if (param != NULL)
-                kfree(param);
-
+        kfree(param);
         return ret;
 }
 #endif /* PRISM2_DOWNLOAD_SUPPORT */
@@ -3890,9 +3887,7 @@ static int prism2_ioctl_priv_hostapd(local_info_t *local, struct iw_point *p)
         }
 
  out:
-        if (param != NULL)
-                kfree(param);
-
+        kfree(param);
         return ret;
 }
 
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index de4e6c23e4b8..3db0c32afe82 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -4030,6 +4030,10 @@ static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
         int i;
 
         rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
+        if (unlikely(!rxq)) {
+                IPW_ERROR("memory allocation failed\n");
+                return NULL;
+        }
         memset(rxq, 0, sizeof(*rxq));
         spin_lock_init(&rxq->lock);
         INIT_LIST_HEAD(&rxq->rx_free);
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c
index d3d4ec9e242e..488ab06fb79f 100644
--- a/drivers/net/wireless/orinoco.c
+++ b/drivers/net/wireless/orinoco.c
@@ -490,7 +490,8 @@ static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
                 return 0;
         }
 
-        /* Check packet length, pad short packets, round up odd length */
+        /* Length of the packet body */
+        /* FIXME: what if the skb is smaller than this? */
         len = max_t(int, ALIGN(skb->len, 2), ETH_ZLEN);
         skb = skb_padto(skb, len);
         if (skb == NULL)
@@ -541,13 +542,21 @@ static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
                         stats->tx_errors++;
                         goto fail;
                 }
+                /* Actual xfer length - allow for padding */
+                len = ALIGN(data_len, 2);
+                if (len < ETH_ZLEN - ETH_HLEN)
+                        len = ETH_ZLEN - ETH_HLEN;
         } else { /* IEEE 802.3 frame */
                 data_len = len + ETH_HLEN;
                 data_off = HERMES_802_3_OFFSET;
                 p = skb->data;
+                /* Actual xfer length - round up for odd length packets */
+                len = ALIGN(data_len, 2);
+                if (len < ETH_ZLEN)
+                        len = ETH_ZLEN;
         }
 
-        err = hermes_bap_pwrite(hw, USER_BAP, p, data_len,
+        err = hermes_bap_pwrite_pad(hw, USER_BAP, p, data_len, len,
                                 txfid, data_off);
         if (err) {
                 printk(KERN_ERR "%s: Error %d writing packet to BAP\n",
diff --git a/drivers/net/wireless/prism54/islpci_dev.c b/drivers/net/wireless/prism54/islpci_dev.c
index 6c9584a9f284..78bdb359835e 100644
--- a/drivers/net/wireless/prism54/islpci_dev.c
+++ b/drivers/net/wireless/prism54/islpci_dev.c
@@ -754,8 +754,7 @@ islpci_free_memory(islpci_private *priv)
                         pci_unmap_single(priv->pdev, buf->pci_addr,
                                          buf->size, PCI_DMA_FROMDEVICE);
                 buf->pci_addr = 0;
-                if (buf->mem)
-                        kfree(buf->mem);
+                kfree(buf->mem);
                 buf->size = 0;
                 buf->mem = NULL;
         }
diff --git a/drivers/net/wireless/prism54/islpci_eth.c b/drivers/net/wireless/prism54/islpci_eth.c
index 5952e9960499..3b49efa37ee5 100644
--- a/drivers/net/wireless/prism54/islpci_eth.c
+++ b/drivers/net/wireless/prism54/islpci_eth.c
@@ -97,12 +97,6 @@ islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
         /* lock the driver code */
         spin_lock_irqsave(&priv->slock, flags);
 
-        /* determine the amount of fragments needed to store the frame */
-
-        frame_size = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
-        if (init_wds)
-                frame_size += 6;
-
         /* check whether the destination queue has enough fragments for the frame */
         curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ]);
         if (unlikely(curr_frag - priv->free_data_tx >= ISL38XX_CB_TX_QSIZE)) {
@@ -213,6 +207,7 @@ islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
         /* store the skb address for future freeing  */
         priv->data_low_tx[index] = skb;
         /* set the proper fragment start address and size information */
+        frame_size = skb->len;
         fragment->size = cpu_to_le16(frame_size);
         fragment->flags = cpu_to_le16(0);       /* set to 1 if more fragments */
         fragment->address = cpu_to_le32(pci_map_address);
@@ -246,12 +241,10 @@ islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
         return 0;
 
       drop_free:
-        /* free the skbuf structure before aborting */
-        dev_kfree_skb(skb);
-        skb = NULL;
-
         priv->statistics.tx_dropped++;
         spin_unlock_irqrestore(&priv->slock, flags);
+        dev_kfree_skb(skb);
+        skb = NULL;
         return err;
 }
 
diff --git a/drivers/net/wireless/prism54/islpci_mgt.c b/drivers/net/wireless/prism54/islpci_mgt.c
index 4937a5ad4b2c..6a60c5970cb5 100644
--- a/drivers/net/wireless/prism54/islpci_mgt.c
+++ b/drivers/net/wireless/prism54/islpci_mgt.c
@@ -137,7 +137,7 @@ islpci_mgmt_rx_fill(struct net_device *ndev)
                                                        PCI_DMA_FROMDEVICE);
                         if (!buf->pci_addr) {
                                 printk(KERN_WARNING
-                                       "Failed to make memory DMA'able\n.");
+                                       "Failed to make memory DMA'able.\n");
                                 return -ENOMEM;
                         }
                 }
diff --git a/drivers/net/wireless/prism54/oid_mgt.c b/drivers/net/wireless/prism54/oid_mgt.c
index 12123e24b113..eea2f04c8c6d 100644
--- a/drivers/net/wireless/prism54/oid_mgt.c
+++ b/drivers/net/wireless/prism54/oid_mgt.c
@@ -268,11 +268,10 @@ mgt_clean(islpci_private *priv)
 
         if (!priv->mib)
                 return;
-        for (i = 0; i < OID_NUM_LAST; i++)
-                if (priv->mib[i]) {
-                        kfree(priv->mib[i]);
-                        priv->mib[i] = NULL;
-                }
+        for (i = 0; i < OID_NUM_LAST; i++) {
+                kfree(priv->mib[i]);
+                priv->mib[i] = NULL;
+        }
         kfree(priv->mib);
         priv->mib = NULL;
 }
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index 7bc7fc823128..d25264ba0c0e 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -860,12 +860,9 @@ static int allocate_buffers(struct strip *strip_info, int mtu)
                 strip_info->mtu = dev->mtu = mtu;
                 return (1);
         }
-        if (r)
-                kfree(r);
-        if (s)
-                kfree(s);
-        if (t)
-                kfree(t);
+        kfree(r);
+        kfree(s);
+        kfree(t);
         return (0);
 }
 
@@ -922,13 +919,9 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
         printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
                strip_info->dev->name, old_mtu, strip_info->mtu);
 
-        if (orbuff)
-                kfree(orbuff);
-        if (osbuff)
-                kfree(osbuff);
-        if (otbuff)
-                kfree(otbuff);
-
+        kfree(orbuff);
+        kfree(osbuff);
+        kfree(otbuff);
         return 0;
 }
 
@@ -2498,18 +2491,13 @@ static int strip_close_low(struct net_device *dev)
         /*
          * Free all STRIP frame buffers.
          */
-        if (strip_info->rx_buff) {
-                kfree(strip_info->rx_buff);
-                strip_info->rx_buff = NULL;
-        }
-        if (strip_info->sx_buff) {
-                kfree(strip_info->sx_buff);
-                strip_info->sx_buff = NULL;
-        }
-        if (strip_info->tx_buff) {
-                kfree(strip_info->tx_buff);
-                strip_info->tx_buff = NULL;
-        }
+        kfree(strip_info->rx_buff);
+        strip_info->rx_buff = NULL;
+        kfree(strip_info->sx_buff);
+        strip_info->sx_buff = NULL;
+        kfree(strip_info->tx_buff);
+        strip_info->tx_buff = NULL;
+
         del_timer(&strip_info->idle_timer);
         return 0;
 }
diff --git a/drivers/pci/hotplug/cpcihp_generic.c b/drivers/pci/hotplug/cpcihp_generic.c
index a62a4345b466..2d4639d6841f 100644
--- a/drivers/pci/hotplug/cpcihp_generic.c
+++ b/drivers/pci/hotplug/cpcihp_generic.c
@@ -39,6 +39,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/pci.h>
+#include <linux/string.h>
 #include "cpci_hotplug.h"
 
 #define DRIVER_VERSION  "0.1"
diff --git a/drivers/pci/hotplug/cpcihp_zt5550.c b/drivers/pci/hotplug/cpcihp_zt5550.c
index 790abadd816c..f7cb00da38df 100644
--- a/drivers/pci/hotplug/cpcihp_zt5550.c
+++ b/drivers/pci/hotplug/cpcihp_zt5550.c
@@ -36,6 +36,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/pci.h>
+#include <linux/signal.h>       /* SA_SHIRQ */
 #include "cpci_hotplug.h"
 #include "cpcihp_zt5550.h"
 
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 8e47fa66e25e..060d74775d7b 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -37,6 +37,8 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include "pci_hotplug.h"
 #include "../pci.h"
 
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 0392e004258f..aabf1e70b528 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -1077,7 +1077,7 @@ static int enable_slot(struct hotplug_slot *hs)
         if (rc) {
                 err("Adding this card exceeds the limitations of this bus.\n");
                 err("(i.e., >1 133MHz cards running on same bus, or "
-                     ">2 66 PCI cards running on same bus\n.");
+                     ">2 66 PCI cards running on same bus.\n");
                 err("Try hot-adding into another bus\n");
                 rc = -EINVAL;
                 goto error_nopower;
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 33b539b34f7e..ff17d8e07e94 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -113,7 +113,7 @@ int pciehp_unconfigure_device(struct pci_func* func)
  */
 int pciehp_set_irq (u8 bus_num, u8 dev_num, u8 int_pin, u8 irq_num)
 {
-#if defined(CONFIG_X86) && !defined(CONFIG_X86_IO_APIC) && !defined(CONFIG_X86_64)
+#if defined(CONFIG_X86_32) && !defined(CONFIG_X86_IO_APIC)
         int rc;
         u16 temp_word;
         struct pci_dev fakedev;
diff --git a/drivers/pci/hotplug/pciehprm_nonacpi.c b/drivers/pci/hotplug/pciehprm_nonacpi.c
index 3622965f8961..33b2c69a0829 100644
--- a/drivers/pci/hotplug/pciehprm_nonacpi.c
+++ b/drivers/pci/hotplug/pciehprm_nonacpi.c
@@ -33,10 +33,13 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/slab.h>
+
 #include <asm/uaccess.h>
 #ifdef CONFIG_IA64
 #include <asm/iosapic.h>
 #endif
+
 #include "pciehp.h"
 #include "pciehprm.h"
 #include "pciehprm_nonacpi.h"
diff --git a/drivers/pci/hotplug/rpadlpar_core.c b/drivers/pci/hotplug/rpadlpar_core.c
index ad1017da8656..fcb66b9a0e28 100644
--- a/drivers/pci/hotplug/rpadlpar_core.c
+++ b/drivers/pci/hotplug/rpadlpar_core.c
@@ -16,10 +16,13 @@
  */
 #include <linux/init.h>
 #include <linux/pci.h>
+#include <linux/string.h>
+
 #include <asm/pci-bridge.h>
 #include <asm/semaphore.h>
 #include <asm/rtas.h>
 #include <asm/vio.h>
+
 #include "../pci.h"
 #include "rpaphp.h"
 #include "rpadlpar.h"
diff --git a/drivers/pci/hotplug/rpaphp_pci.c b/drivers/pci/hotplug/rpaphp_pci.c
index 46c157d26a2f..f7c12d7dfcfc 100644
--- a/drivers/pci/hotplug/rpaphp_pci.c
+++ b/drivers/pci/hotplug/rpaphp_pci.c
@@ -23,11 +23,13 @@
  *
  */
 #include <linux/pci.h>
+#include <linux/string.h>
+
 #include <asm/pci-bridge.h>
 #include <asm/rtas.h>
 #include <asm/machdep.h>
-#include "../pci.h"             /* for pci_add_new_bus */
 
+#include "../pci.h"             /* for pci_add_new_bus */
 #include "rpaphp.h"
 
 static struct pci_bus *find_bus_among_children(struct pci_bus *bus,
diff --git a/drivers/pci/hotplug/rpaphp_slot.c b/drivers/pci/hotplug/rpaphp_slot.c
index 0e8815495083..daa89ae57123 100644
--- a/drivers/pci/hotplug/rpaphp_slot.c
+++ b/drivers/pci/hotplug/rpaphp_slot.c
@@ -27,6 +27,9 @@
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
 #include <linux/pci.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
 #include <asm/rtas.h>
 #include "rpaphp.h"
 
diff --git a/drivers/pci/hotplug/shpchp.h b/drivers/pci/hotplug/shpchp.h
index abe2cf411e68..08ad26a0cae7 100644
--- a/drivers/pci/hotplug/shpchp.h
+++ b/drivers/pci/hotplug/shpchp.h
@@ -32,6 +32,8 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/sched.h>        /* signal_pending(), struct timer_list */
+
 #include "pci_hotplug.h"
 
 #if !defined(MODULE)
diff --git a/drivers/pci/hotplug/shpchprm_nonacpi.c b/drivers/pci/hotplug/shpchprm_nonacpi.c
index d70fe5408417..c6b40998eeb3 100644
--- a/drivers/pci/hotplug/shpchprm_nonacpi.c
+++ b/drivers/pci/hotplug/shpchprm_nonacpi.c
@@ -32,6 +32,8 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
+
 #include "shpchp.h"
 
 int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 8972e6a3aac0..ae986e590b48 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -8,6 +8,8 @@
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/mempolicy.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include "pci.h"
 
 /*
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 61b855c99e39..e74d75843047 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -15,6 +15,7 @@
 #include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
+#include <linux/string.h>
 #include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include "pci.h"
 
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index 14f05d22bb70..467a4ceccf10 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -11,6 +11,8 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/pm.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/pcieport_if.h>
 
 #include "portdrv.h"
diff --git a/drivers/pci/pcie/portdrv_pci.c b/drivers/pci/pcie/portdrv_pci.c
index 3c565ce7f77b..02260141dc81 100644
--- a/drivers/pci/pcie/portdrv_pci.c
+++ b/drivers/pci/pcie/portdrv_pci.c
@@ -12,6 +12,7 @@
 #include <linux/errno.h>
 #include <linux/pm.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/pcieport_if.h>
 
 #include "portdrv.h"
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index bbd9c2323d8c..5627ce1d2b32 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -356,7 +356,7 @@ static void piix4_mem_quirk(struct pci_dev *dev, const char *name, unsigned int
 /*
  * PIIX4 ACPI: Two IO regions pointed to by longwords at
  *      0x40 (64 bytes of ACPI registers)
- *      0x90 (32 bytes of SMB registers)
+ *      0x90 (16 bytes of SMB registers)
  * and a few strange programmable PIIX4 device resources.
  */
 static void __devinit quirk_piix4_acpi(struct pci_dev *dev)
@@ -366,7 +366,7 @@ static void __devinit quirk_piix4_acpi(struct pci_dev *dev)
         pci_read_config_dword(dev, 0x40, &region);
         quirk_io_region(dev, region, 64, PCI_BRIDGE_RESOURCES, "PIIX4 ACPI");
         pci_read_config_dword(dev, 0x90, &region);
-        quirk_io_region(dev, region, 32, PCI_BRIDGE_RESOURCES+1, "PIIX4 SMB");
+        quirk_io_region(dev, region, 16, PCI_BRIDGE_RESOURCES+1, "PIIX4 SMB");
 
         /* Device resource A has enables for some of the other ones */
         pci_read_config_dword(dev, 0x5c, &res_a);
diff --git a/drivers/pci/rom.c b/drivers/pci/rom.c
index 49bd21702314..598a115cd00e 100644
--- a/drivers/pci/rom.c
+++ b/drivers/pci/rom.c
@@ -9,6 +9,7 @@
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include "pci.h"
 
diff --git a/drivers/pcmcia/Kconfig b/drivers/pcmcia/Kconfig
index 36cc9a96a338..ccf20039e909 100644
--- a/drivers/pcmcia/Kconfig
+++ b/drivers/pcmcia/Kconfig
@@ -154,6 +154,16 @@ config TCIC
           "Bridge" is the name used for the hardware inside your computer that
           PCMCIA cards are plugged into. If unsure, say N.
 
+config PCMCIA_M8XX
+        tristate "MPC8xx PCMCIA support"
+        depends on PCMCIA && PPC
+        select PCCARD_NONSTATIC
+        help
+        Say Y here to include support for PowerPC 8xx series PCMCIA
+        controller.
+
+        This driver is also available as a module called m8xx_pcmcia.
+
 config HD64465_PCMCIA
         tristate "HD64465 host bridge support"
         depends on HD64465 && PCMCIA
diff --git a/drivers/pcmcia/Makefile b/drivers/pcmcia/Makefile
index a41fbb38fdcb..fe37541abbfe 100644
--- a/drivers/pcmcia/Makefile
+++ b/drivers/pcmcia/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_PD6729)				+= pd6729.o
 obj-$(CONFIG_I82365)                            += i82365.o
 obj-$(CONFIG_I82092)                            += i82092.o
 obj-$(CONFIG_TCIC)                              += tcic.o
+obj-$(CONFIG_PCMCIA_M8XX)                              += m8xx_pcmcia.o
 obj-$(CONFIG_HD64465_PCMCIA)                    += hd64465_ss.o
 obj-$(CONFIG_PCMCIA_SA1100)                     += sa11xx_core.o sa1100_cs.o
 obj-$(CONFIG_PCMCIA_SA1111)                     += sa11xx_core.o sa1111_cs.o
@@ -42,9 +43,11 @@ pxa2xx_core-y					+= soc_common.o pxa2xx_base.o
 au1x00_ss-y                                     += au1000_generic.o
 au1x00_ss-$(CONFIG_MIPS_PB1000)                 += au1000_pb1x00.o
 au1x00_ss-$(CONFIG_MIPS_PB1100)                 += au1000_pb1x00.o
+au1x00_ss-$(CONFIG_MIPS_PB1200)                 += au1000_db1x00.o
 au1x00_ss-$(CONFIG_MIPS_PB1500)                 += au1000_pb1x00.o
 au1x00_ss-$(CONFIG_MIPS_DB1000)                 += au1000_db1x00.o
 au1x00_ss-$(CONFIG_MIPS_DB1100)                 += au1000_db1x00.o
+au1x00_ss-$(CONFIG_MIPS_DB1200)                 += au1000_db1x00.o
 au1x00_ss-$(CONFIG_MIPS_DB1500)                 += au1000_db1x00.o
 au1x00_ss-$(CONFIG_MIPS_DB1550)                 += au1000_db1x00.o
 au1x00_ss-$(CONFIG_MIPS_XXS1500)               += au1000_xxs1500.o
@@ -57,6 +60,7 @@ sa1111_cs-$(CONFIG_SA1100_JORNADA720)		+= sa1100_jornada720.o
 sa1100_cs-y                                     += sa1100_generic.o
 sa1100_cs-$(CONFIG_SA1100_ASSABET)              += sa1100_assabet.o
 sa1100_cs-$(CONFIG_SA1100_CERF)                 += sa1100_cerf.o
+sa1100_cs-$(CONFIG_SA1100_COLLIE)              += pxa2xx_sharpsl.o
 sa1100_cs-$(CONFIG_SA1100_H3600)                += sa1100_h3600.o
 sa1100_cs-$(CONFIG_SA1100_SHANNON)              += sa1100_shannon.o
 sa1100_cs-$(CONFIG_SA1100_SIMPAD)               += sa1100_simpad.o
diff --git a/drivers/pcmcia/au1000_db1x00.c b/drivers/pcmcia/au1000_db1x00.c
index 42cf8bfbcc98..24cfee1a412c 100644
--- a/drivers/pcmcia/au1000_db1x00.c
+++ b/drivers/pcmcia/au1000_db1x00.c
@@ -40,7 +40,15 @@
 #include <asm/irq.h>
 #include <asm/signal.h>
 #include <asm/mach-au1x00/au1000.h>
-#include <asm/mach-db1x00/db1x00.h>
+
+#if defined(CONFIG_MIPS_DB1200)
+        #include <db1200.h>
+#elif defined(CONFIG_MIPS_PB1200)
+        #include <pb1200.h>
+#else
+        #include <asm/mach-db1x00/db1x00.h>
+        static BCSR * const bcsr = (BCSR *)BCSR_KSEG1_ADDR;
+#endif
 
 #include "au1000_generic.h"
 
@@ -50,7 +58,6 @@
 #define debug(x,args...)
 #endif
 
-static BCSR * const bcsr = (BCSR *)BCSR_KSEG1_ADDR;
 
 struct au1000_pcmcia_socket au1000_pcmcia_socket[PCMCIA_NUM_SOCKS];
 extern int au1x00_pcmcia_socket_probe(struct device *, struct pcmcia_low_level *, int, int);
@@ -59,6 +66,8 @@ static int db1x00_pcmcia_hw_init(struct au1000_pcmcia_socket *skt)
 {
 #ifdef CONFIG_MIPS_DB1550
         skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_3;
+#elif defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
+        skt->irq = skt->nr ? BOARD_PC1_INT : BOARD_PC0_INT;
 #else
         skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_2;
 #endif
@@ -85,11 +94,19 @@ db1x00_pcmcia_socket_state(struct au1000_pcmcia_socket *skt, struct pcmcia_state
         switch (skt->nr) {
         case 0:
                 vs = bcsr->status & 0x3;
+#if defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
+                inserted = BOARD_CARD_INSERTED(0);
+#else
                 inserted = !(bcsr->status & (1<<4));
+#endif
                 break;
         case 1:
                 vs = (bcsr->status & 0xC)>>2;
+#if defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
+                inserted = BOARD_CARD_INSERTED(1);
+#else
                 inserted = !(bcsr->status & (1<<5));
+#endif
                 break;
         default:/* should never happen */
                 return;
diff --git a/drivers/pcmcia/au1000_generic.c b/drivers/pcmcia/au1000_generic.c
index f591839ab9cd..87302c548c24 100644
--- a/drivers/pcmcia/au1000_generic.c
+++ b/drivers/pcmcia/au1000_generic.c
@@ -490,7 +490,7 @@ int au1x00_drv_pcmcia_remove(struct device *dev)
                 flush_scheduled_work();
                 skt->ops->hw_shutdown(skt);
                 au1x00_pcmcia_config_skt(skt, &dead_socket);
-                iounmap(skt->virt_io);
+                iounmap(skt->virt_io + (u32)mips_io_port_base);
                 skt->virt_io = NULL;
         }
 
@@ -528,10 +528,6 @@ static struct device_driver au1x00_pcmcia_driver = {
         .resume         = pcmcia_socket_dev_resume,
 };
 
-static struct platform_device au1x00_device = {
-        .name = "au1x00-pcmcia",
-        .id = 0,
-};
 
 /* au1x00_pcmcia_init()
  *
@@ -545,7 +541,6 @@ static int __init au1x00_pcmcia_init(void)
         int error = 0;
         if ((error = driver_register(&au1x00_pcmcia_driver)))
                 return error;
-        platform_device_register(&au1x00_device);
         return error;
 }
 
@@ -556,7 +551,6 @@ static int __init au1x00_pcmcia_init(void)
 static void __exit au1x00_pcmcia_exit(void)
 {
         driver_unregister(&au1x00_pcmcia_driver);
-        platform_device_unregister(&au1x00_device);
 }
 
 module_init(au1x00_pcmcia_init);
diff --git a/drivers/pcmcia/au1000_generic.h b/drivers/pcmcia/au1000_generic.h
index d5122b1ea94b..b0e7908392a7 100644
--- a/drivers/pcmcia/au1000_generic.h
+++ b/drivers/pcmcia/au1000_generic.h
@@ -44,13 +44,13 @@
 /* pcmcia socket 1 needs external glue logic so the memory map
  * differs from board to board.
  */
-#if defined(CONFIG_MIPS_PB1000) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1550)
+#if defined(CONFIG_MIPS_PB1000) || defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1550) || defined(CONFIG_MIPS_PB1200)
 #define AU1X_SOCK1_IO        0xF08000000
 #define AU1X_SOCK1_PHYS_ATTR 0xF48000000
 #define AU1X_SOCK1_PHYS_MEM  0xF88000000
 #define AU1X_SOCK1_PSEUDO_PHYS_ATTR 0xF4800000
 #define AU1X_SOCK1_PSEUDO_PHYS_MEM  0xF8800000
-#elif defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100) || defined(CONFIG_MIPS_DB1500) || defined(CONFIG_MIPS_DB1550)
+#elif defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100) || defined(CONFIG_MIPS_DB1500) || defined(CONFIG_MIPS_DB1550) || defined(CONFIG_MIPS_DB1200)
 #define AU1X_SOCK1_IO        0xF04000000
 #define AU1X_SOCK1_PHYS_ATTR 0xF44000000
 #define AU1X_SOCK1_PHYS_MEM  0xF84000000
diff --git a/drivers/pcmcia/m8xx_pcmcia.c b/drivers/pcmcia/m8xx_pcmcia.c
new file mode 100644
index 000000000000..f8bed87cf2f1
--- /dev/null
+++ b/drivers/pcmcia/m8xx_pcmcia.c
@@ -0,0 +1,1290 @@
+/*
+ * m8xx_pcmcia.c - Linux PCMCIA socket driver for the mpc8xx series.
+ *
+ * (C) 1999-2000 Magnus Damm <damm@bitsmart.com>
+ * (C) 2001-2002 Montavista Software, Inc.
+ *     <mlocke@mvista.com>
+ *
+ * Support for two slots by Cyclades Corporation
+ *     <oliver.kurth@cyclades.de>
+ * Further fixes, v2.6 kernel port
+ *     <marcelo.tosatti@cyclades.com>
+ *
+ * "The ExCA standard specifies that socket controllers should provide
+ * two IO and five memory windows per socket, which can be independently
+ * configured and positioned in the host address space and mapped to
+ * arbitrary segments of card address space. " - David A Hinds. 1999
+ *
+ * This controller does _not_ meet the ExCA standard.
+ *
+ * m8xx pcmcia controller brief info:
+ * + 8 windows (attrib, mem, i/o)
+ * + up to two slots (SLOT_A and SLOT_B)
+ * + inputpins, outputpins, event and mask registers.
+ * - no offset register. sigh.
+ *
+ * Because of the lacking offset register we must map the whole card.
+ * We assign each memory window PCMCIA_MEM_WIN_SIZE address space.
+ * Make sure there is (PCMCIA_MEM_WIN_SIZE * PCMCIA_MEM_WIN_NO
+ * * PCMCIA_SOCKETS_NO) bytes at PCMCIA_MEM_WIN_BASE.
+ * The i/o windows are dynamically allocated at PCMCIA_IO_WIN_BASE.
+ * They are maximum 64KByte each...
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/fcntl.h>
+#include <linux/string.h>
+
+#include <asm/io.h>
+#include <asm/bitops.h>
+#include <asm/segment.h>
+#include <asm/system.h>
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+
+#include <asm/mpc8xx.h>
+#include <asm/8xx_immap.h>
+#include <asm/irq.h>
+
+#include <pcmcia/version.h>
+#include <pcmcia/cs_types.h>
+#include <pcmcia/cs.h>
+#include <pcmcia/ss.h>
+
+#ifdef PCMCIA_DEBUG
+static int pc_debug = PCMCIA_DEBUG;
+module_param(pc_debug, int, 0);
+#define dprintk(args...) printk(KERN_DEBUG "m8xx_pcmcia: " args);
+#else
+#define dprintk(args...)
+#endif
+
+#define pcmcia_info(args...) printk(KERN_INFO "m8xx_pcmcia: "args)
+#define pcmcia_error(args...) printk(KERN_ERR "m8xx_pcmcia: "args)
+
+static const char *version = "Version 0.06, Aug 2005";
+MODULE_LICENSE("Dual MPL/GPL");
+
+#if !defined(CONFIG_PCMCIA_SLOT_A) && !defined(CONFIG_PCMCIA_SLOT_B)
+
+/* The RPX series use SLOT_B */
+#if defined(CONFIG_RPXCLASSIC) || defined(CONFIG_RPXLITE)
+#define CONFIG_PCMCIA_SLOT_B
+#define CONFIG_BD_IS_MHZ
+#endif
+
+/* The ADS board use SLOT_A */
+#ifdef CONFIG_ADS
+#define CONFIG_PCMCIA_SLOT_A
+#define CONFIG_BD_IS_MHZ
+#endif
+
+/* The FADS series are a mess */
+#ifdef CONFIG_FADS
+#if defined(CONFIG_MPC860T) || defined(CONFIG_MPC860) || defined(CONFIG_MPC821)
+#define CONFIG_PCMCIA_SLOT_A
+#else
+#define CONFIG_PCMCIA_SLOT_B
+#endif
+#endif
+
+/* Cyclades ACS uses both slots */
+#ifdef CONFIG_PRxK
+#define CONFIG_PCMCIA_SLOT_A
+#define CONFIG_PCMCIA_SLOT_B
+#endif
+
+#endif /* !defined(CONFIG_PCMCIA_SLOT_A) && !defined(CONFIG_PCMCIA_SLOT_B) */
+
+#if defined(CONFIG_PCMCIA_SLOT_A) && defined(CONFIG_PCMCIA_SLOT_B)
+
+#define PCMCIA_SOCKETS_NO 2
+/* We have only 8 windows, dualsocket support will be limited. */
+#define PCMCIA_MEM_WIN_NO 2
+#define PCMCIA_IO_WIN_NO  2
+#define PCMCIA_SLOT_MSG "SLOT_A and SLOT_B"
+
+#elif defined(CONFIG_PCMCIA_SLOT_A) || defined(CONFIG_PCMCIA_SLOT_B)
+
+#define PCMCIA_SOCKETS_NO 1
+/* full support for one slot */
+#define PCMCIA_MEM_WIN_NO 5
+#define PCMCIA_IO_WIN_NO  2
+
+/* define _slot_ to be able to optimize macros */
+
+#ifdef CONFIG_PCMCIA_SLOT_A
+#define _slot_ 0
+#define PCMCIA_SLOT_MSG "SLOT_A"
+#else
+#define _slot_ 1
+#define PCMCIA_SLOT_MSG "SLOT_B"
+#endif
+
+#else
+#error m8xx_pcmcia: Bad configuration!
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#define PCMCIA_MEM_WIN_BASE 0xe0000000 /* base address for memory window 0   */
+#define PCMCIA_MEM_WIN_SIZE 0x04000000 /* each memory window is 64 MByte     */
+#define PCMCIA_IO_WIN_BASE  _IO_BASE   /* base address for io window 0       */
+
+#define PCMCIA_SCHLVL PCMCIA_INTERRUPT /* Status Change Interrupt Level      */
+
+/* ------------------------------------------------------------------------- */
+
+/* 2.4.x and newer has this always in HZ */
+#define M8XX_BUSFREQ ((((bd_t *)&(__res))->bi_busfreq))
+
+static int pcmcia_schlvl = PCMCIA_SCHLVL;
+
+static spinlock_t events_lock = SPIN_LOCK_UNLOCKED;
+
+
+#define PCMCIA_SOCKET_KEY_5V 1
+#define PCMCIA_SOCKET_KEY_LV 2
+
+/* look up table for pgcrx registers */
+static u32 *m8xx_pgcrx[2] = {
+        &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pgcra,
+        &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pgcrb
+};
+
+/*
+ * This structure is used to address each window in the PCMCIA controller.
+ *
+ * Keep in mind that we assume that pcmcia_win[n+1] is mapped directly
+ * after pcmcia_win[n]...
+ */
+
+struct pcmcia_win {
+        u32     br;
+        u32     or;
+};
+
+/*
+ * For some reason the hardware guys decided to make both slots share
+ * some registers.
+ *
+ * Could someone invent object oriented hardware ?
+ *
+ * The macros are used to get the right bit from the registers.
+ * SLOT_A : slot = 0
+ * SLOT_B : slot = 1
+ */
+
+#define M8XX_PCMCIA_VS1(slot)      (0x80000000 >> (slot << 4))
+#define M8XX_PCMCIA_VS2(slot)      (0x40000000 >> (slot << 4))
+#define M8XX_PCMCIA_VS_MASK(slot)  (0xc0000000 >> (slot << 4))
+#define M8XX_PCMCIA_VS_SHIFT(slot) (30 - (slot << 4))
+
+#define M8XX_PCMCIA_WP(slot)       (0x20000000 >> (slot << 4))
+#define M8XX_PCMCIA_CD2(slot)      (0x10000000 >> (slot << 4))
+#define M8XX_PCMCIA_CD1(slot)      (0x08000000 >> (slot << 4))
+#define M8XX_PCMCIA_BVD2(slot)     (0x04000000 >> (slot << 4))
+#define M8XX_PCMCIA_BVD1(slot)     (0x02000000 >> (slot << 4))
+#define M8XX_PCMCIA_RDY(slot)      (0x01000000 >> (slot << 4))
+#define M8XX_PCMCIA_RDY_L(slot)    (0x00800000 >> (slot << 4))
+#define M8XX_PCMCIA_RDY_H(slot)    (0x00400000 >> (slot << 4))
+#define M8XX_PCMCIA_RDY_R(slot)    (0x00200000 >> (slot << 4))
+#define M8XX_PCMCIA_RDY_F(slot)    (0x00100000 >> (slot << 4))
+#define M8XX_PCMCIA_MASK(slot)     (0xFFFF0000 >> (slot << 4))
+
+#define M8XX_PCMCIA_POR_VALID    0x00000001
+#define M8XX_PCMCIA_POR_WRPROT   0x00000002
+#define M8XX_PCMCIA_POR_ATTRMEM  0x00000010
+#define M8XX_PCMCIA_POR_IO       0x00000018
+#define M8XX_PCMCIA_POR_16BIT    0x00000040
+
+#define M8XX_PGCRX(slot)  m8xx_pgcrx[slot]
+
+#define M8XX_PGCRX_CXOE    0x00000080
+#define M8XX_PGCRX_CXRESET 0x00000040
+
+/* we keep one lookup table per socket to check flags */
+
+#define PCMCIA_EVENTS_MAX 5  /* 4 max at a time + termination */
+
+struct event_table {
+        u32 regbit;
+        u32 eventbit;
+};
+
+struct socket_info {
+        void    (*handler)(void *info, u32 events);
+        void    *info;
+
+        u32 slot;
+
+        socket_state_t state;
+        struct pccard_mem_map mem_win[PCMCIA_MEM_WIN_NO];
+        struct pccard_io_map  io_win[PCMCIA_IO_WIN_NO];
+        struct event_table events[PCMCIA_EVENTS_MAX];
+        struct pcmcia_socket socket;
+};
+
+static struct socket_info socket[PCMCIA_SOCKETS_NO];
+
+/*
+ * Search this table to see if the windowsize is
+ * supported...
+ */
+
+#define M8XX_SIZES_NO 32
+
+static const u32 m8xx_size_to_gray[M8XX_SIZES_NO] =
+{
+        0x00000001, 0x00000002, 0x00000008, 0x00000004,
+        0x00000080, 0x00000040, 0x00000010, 0x00000020,
+        0x00008000, 0x00004000, 0x00001000, 0x00002000,
+        0x00000100, 0x00000200, 0x00000800, 0x00000400,
+
+        0x0fffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0x01000000, 0x02000000, 0xffffffff, 0x04000000,
+        0x00010000, 0x00020000, 0x00080000, 0x00040000,
+        0x00800000, 0x00400000, 0x00100000, 0x00200000
+};
+
+/* ------------------------------------------------------------------------- */
+
+static irqreturn_t m8xx_interrupt(int irq, void *dev, struct pt_regs *regs);
+
+#define PCMCIA_BMT_LIMIT (15*4)  /* Bus Monitor Timeout value */
+
+/* ------------------------------------------------------------------------- */
+/* board specific stuff:                                                     */
+/* voltage_set(), hardware_enable() and hardware_disable()                   */
+/* ------------------------------------------------------------------------- */
+/* RPX Boards from Embedded Planet                                           */
+
+#if defined(CONFIG_RPXCLASSIC) || defined(CONFIG_RPXLITE)
+
+/* The RPX boards seems to have it's bus monitor timeout set to 6*8 clocks.
+ * SYPCR is write once only, therefore must the slowest memory be faster
+ * than the bus monitor or we will get a machine check due to the bus timeout.
+ */
+
+#define PCMCIA_BOARD_MSG "RPX CLASSIC or RPX LITE"
+
+#undef PCMCIA_BMT_LIMIT
+#define PCMCIA_BMT_LIMIT (6*8)
+
+static int voltage_set(int slot, int vcc, int vpp)
+{
+        u32 reg = 0;
+
+        switch(vcc) {
+        case 0: break;
+        case 33:
+                reg |= BCSR1_PCVCTL4;
+                break;
+        case 50:
+                reg |= BCSR1_PCVCTL5;
+                break;
+        default:
+                return 1;
+        }
+
+        switch(vpp) {
+        case 0: break;
+        case 33:
+        case 50:
+                if(vcc == vpp)
+                        reg |= BCSR1_PCVCTL6;
+                else
+                        return 1;
+                break;
+        case 120:
+                reg |= BCSR1_PCVCTL7;
+        default:
+                return 1;
+        }
+
+        if(!((vcc == 50) || (vcc == 0)))
+                return 1;
+
+        /* first, turn off all power */
+
+        out_be32(((u32 *)RPX_CSR_ADDR), in_be32(((u32 *)RPX_CSR_ADDR)) & ~(BCSR1_PCVCTL4 | BCSR1_PCVCTL5 | BCSR1_PCVCTL6 | BCSR1_PCVCTL7));
+
+        /* enable new powersettings */
+
+        out_be32(((u32 *)RPX_CSR_ADDR), in_be32(((u32 *)RPX_CSR_ADDR)) | reg);
+
+        return 0;
+}
+
+#define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
+#define hardware_enable(_slot_)  /* No hardware to enable */
+#define hardware_disable(_slot_) /* No hardware to disable */
+
+#endif /* CONFIG_RPXCLASSIC */
+
+/* FADS Boards from Motorola                                               */
+
+#if defined(CONFIG_FADS)
+
+#define PCMCIA_BOARD_MSG "FADS"
+
+static int voltage_set(int slot, int vcc, int vpp)
+{
+        u32 reg = 0;
+
+        switch(vcc) {
+                case 0:
+                        break;
+                case 33:
+                        reg |= BCSR1_PCCVCC0;
+                        break;
+                case 50:
+                        reg |= BCSR1_PCCVCC1;
+                        break;
+                default:
+                        return 1;
+        }
+
+        switch(vpp) {
+                case 0:
+                        break;
+                case 33:
+                case 50:
+                        if(vcc == vpp)
+                                reg |= BCSR1_PCCVPP1;
+                        else
+                                return 1;
+                        break;
+                case 120:
+                        if ((vcc == 33) || (vcc == 50))
+                                reg |= BCSR1_PCCVPP0;
+                        else
+                                return 1;
+                default:
+                        return 1;
+        }
+
+        /* first, turn off all power */
+        out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) & ~(BCSR1_PCCVCC_MASK | BCSR1_PCCVPP_MASK));
+
+        /* enable new powersettings */
+        out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) | reg);
+
+        return 0;
+}
+
+#define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
+
+static void hardware_enable(int slot)
+{
+        out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) & ~BCSR1_PCCEN);
+}
+
+static void hardware_disable(int slot)
+{
+        out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) |  BCSR1_PCCEN);
+}
+
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* Motorola MBX860                                                           */
+
+#if defined(CONFIG_MBX)
+
+#define PCMCIA_BOARD_MSG "MBX"
+
+static int voltage_set(int slot, int vcc, int vpp)
+{
+        u8 reg = 0;
+
+        switch(vcc) {
+                case 0:
+                        break;
+                case 33:
+                        reg |= CSR2_VCC_33;
+                        break;
+                case 50:
+                        reg |= CSR2_VCC_50;
+                        break;
+                default:
+                        return 1;
+        }
+
+        switch(vpp) {
+                case 0:
+                        break;
+                case 33:
+                case 50:
+                        if(vcc == vpp)
+                                reg |= CSR2_VPP_VCC;
+                        else
+                                return 1;
+                        break;
+                case 120:
+                        if ((vcc == 33) || (vcc == 50))
+                                reg |= CSR2_VPP_12;
+                        else
+                                return 1;
+                default:
+                        return 1;
+        }
+
+        /* first, turn off all power */
+        out_8(&((u8 *)MBX_CSR2_ADDR), in_8(&((u8 *)MBX_CSR2_ADDR)) & ~(CSR2_VCC_MASK | CSR2_VPP_MASK));
+
+        /* enable new powersettings */
+        out_8(&((u8 *)MBX_CSR2_ADDR), in_8(&((u8 *)MBX_CSR2_ADDR)) | reg);
+
+        return 0;
+}
+
+#define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
+#define hardware_enable(_slot_)  /* No hardware to enable */
+#define hardware_disable(_slot_) /* No hardware to disable */
+
+#endif /* CONFIG_MBX */
+
+#if defined(CONFIG_PRxK)
+#include <asm/cpld.h>
+extern volatile fpga_pc_regs *fpga_pc;
+
+#define PCMCIA_BOARD_MSG "MPC855T"
+
+static int voltage_set(int slot, int vcc, int vpp)
+{
+        u8 reg = 0;
+        u8 regread;
+        cpld_regs *ccpld = get_cpld();
+
+        switch(vcc) {
+                case 0:
+                        break;
+                case 33:
+                        reg |= PCMCIA_VCC_33;
+                        break;
+                case 50:
+                        reg |= PCMCIA_VCC_50;
+                        break;
+                default:
+                        return 1;
+        }
+
+        switch(vpp) {
+                case 0:
+                        break;
+                case 33:
+                case 50:
+                        if(vcc == vpp)
+                                reg |= PCMCIA_VPP_VCC;
+                        else
+                                return 1;
+                        break;
+                case 120:
+                        if ((vcc == 33) || (vcc == 50))
+                                reg |= PCMCIA_VPP_12;
+                        else
+                                return 1;
+                default:
+                        return 1;
+        }
+
+        reg = reg >> (slot << 2);
+        regread = in_8(&ccpld->fpga_pc_ctl);
+        if (reg != (regread & ((PCMCIA_VCC_MASK | PCMCIA_VPP_MASK) >> (slot << 2)))) {
+                /* enable new powersettings */
+                regread = regread & ~((PCMCIA_VCC_MASK | PCMCIA_VPP_MASK) >> (slot << 2));
+                out_8(&ccpld->fpga_pc_ctl, reg | regread);
+                msleep(100);
+        }
+
+        return 0;
+}
+
+#define socket_get(_slot_) PCMCIA_SOCKET_KEY_LV
+#define hardware_enable(_slot_)  /* No hardware to enable */
+#define hardware_disable(_slot_) /* No hardware to disable */
+
+#endif /* CONFIG_PRxK */
+
+static void m8xx_shutdown(void)
+{
+        u32 m, i;
+        struct pcmcia_win *w;
+
+        for(i = 0; i < PCMCIA_SOCKETS_NO; i++){
+                w = (void *) &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pbr0;
+
+                out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pscr, M8XX_PCMCIA_MASK(i));
+                out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per, in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per) & ~M8XX_PCMCIA_MASK(i));
+
+                /* turn off interrupt and disable CxOE */
+                out_be32(M8XX_PGCRX(i), M8XX_PGCRX_CXOE);
+
+                /* turn off memory windows */
+                for(m = 0; m < PCMCIA_MEM_WIN_NO; m++) {
+                        out_be32(&w->or, 0); /* set to not valid */
+                        w++;
+                }
+
+                /* turn off voltage */
+                voltage_set(i, 0, 0);
+
+                /* disable external hardware */
+                hardware_disable(i);
+        }
+
+        free_irq(pcmcia_schlvl, NULL);
+}
+
+/* copied from tcic.c */
+
+static int m8xx_drv_suspend(struct device *dev, pm_message_t state, u32 level)
+{
+        int ret = 0;
+        if (level == SUSPEND_SAVE_STATE)
+                ret = pcmcia_socket_dev_suspend(dev, state);
+        return ret;
+}
+
+static int m8xx_drv_resume(struct device *dev, u32 level)
+{
+        int ret = 0;
+        if (level == RESUME_RESTORE_STATE)
+                ret = pcmcia_socket_dev_resume(dev);
+        return ret;
+}
+
+static struct device_driver m8xx_driver = {
+        .name = "m8xx-pcmcia",
+        .bus = &platform_bus_type,
+        .suspend = m8xx_drv_suspend,
+        .resume = m8xx_drv_resume,
+};
+
+static struct platform_device m8xx_device = {
+        .name = "m8xx-pcmcia",
+        .id = 0,
+};
+
+static u32 pending_events[PCMCIA_SOCKETS_NO];
+static spinlock_t pending_event_lock = SPIN_LOCK_UNLOCKED;
+
+static irqreturn_t m8xx_interrupt(int irq, void *dev, struct pt_regs *regs)
+{
+        struct socket_info *s;
+        struct event_table *e;
+        unsigned int i, events, pscr, pipr, per;
+
+        dprintk("Interrupt!\n");
+        /* get interrupt sources */
+
+        pscr = in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pscr);
+        pipr = in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pipr);
+        per = in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per);
+
+        for(i = 0; i < PCMCIA_SOCKETS_NO; i++) {
+                s = &socket[i];
+                e = &s->events[0];
+                events = 0;
+
+                while(e->regbit) {
+                        if(pscr & e->regbit)
+                                events |= e->eventbit;
+
+                                e++;
+                }
+
+                /*
+                 * report only if both card detect signals are the same
+                 * not too nice done,
+                 * we depend on that CD2 is the bit to the left of CD1...
+                 */
+                if(events & SS_DETECT)
+                        if(((pipr & M8XX_PCMCIA_CD2(i)) >> 1) ^
+                                (pipr & M8XX_PCMCIA_CD1(i)))
+                        {
+                                events &= ~SS_DETECT;
+                        }
+
+#ifdef PCMCIA_GLITCHY_CD
+                /*
+                 * I've experienced CD problems with my ADS board.
+                 * We make an extra check to see if there was a
+                 * real change of Card detection.
+                 */
+
+                if((events & SS_DETECT) &&
+                   ((pipr &
+                     (M8XX_PCMCIA_CD2(i) | M8XX_PCMCIA_CD1(i))) == 0) &&
+                   (s->state.Vcc | s->state.Vpp)) {
+                        events &= ~SS_DETECT;
+                        /*printk( "CD glitch workaround - CD = 0x%08x!\n",
+                                (pipr & (M8XX_PCMCIA_CD2(i)
+                                         | M8XX_PCMCIA_CD1(i))));*/
+                }
+#endif
+
+                /* call the handler */
+
+                dprintk("slot %u: events = 0x%02x, pscr = 0x%08x, "
+                        "pipr = 0x%08x\n",
+                        i, events, pscr, pipr);
+
+                if(events) {
+                        spin_lock(&pending_event_lock);
+                        pending_events[i] |= events;
+                        spin_unlock(&pending_event_lock);
+                        /*
+                         * Turn off RDY_L bits in the PER mask on
+                         * CD interrupt receival.
+                         *
+                         * They can generate bad interrupts on the
+                         * ACS4,8,16,32.   - marcelo
+                         */
+                        per &= ~M8XX_PCMCIA_RDY_L(0);
+                        per &= ~M8XX_PCMCIA_RDY_L(1);
+
+                        out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per, per);
+
+                        if (events)
+                                pcmcia_parse_events(&socket[i].socket, events);
+                }
+        }
+
+        /* clear the interrupt sources */
+        out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pscr, pscr);
+
+        dprintk("Interrupt done.\n");
+
+        return IRQ_HANDLED;
+}
+
+static u32 m8xx_get_graycode(u32 size)
+{
+        u32 k;
+
+        for(k = 0; k < M8XX_SIZES_NO; k++)
+                if(m8xx_size_to_gray[k] == size)
+                        break;
+
+        if((k == M8XX_SIZES_NO) || (m8xx_size_to_gray[k] == -1))
+                k = -1;
+
+        return k;
+}
+
+static u32 m8xx_get_speed(u32 ns, u32 is_io)
+{
+        u32 reg, clocks, psst, psl, psht;
+
+        if(!ns) {
+
+                /*
+                 * We get called with IO maps setup to 0ns
+                 * if not specified by the user.
+                 * They should be 255ns.
+                 */
+
+                if(is_io)
+                        ns = 255;
+                else
+                        ns = 100;  /* fast memory if 0 */
+        }
+
+        /*
+         * In PSST, PSL, PSHT fields we tell the controller
+         * timing parameters in CLKOUT clock cycles.
+         * CLKOUT is the same as GCLK2_50.
+         */
+
+/* how we want to adjust the timing - in percent */
+
+#define ADJ 180 /* 80 % longer accesstime - to be sure */
+
+        clocks = ((M8XX_BUSFREQ / 1000) * ns) / 1000;
+        clocks = (clocks * ADJ) / (100*1000);
+        if(clocks >= PCMCIA_BMT_LIMIT) {
+                printk( "Max access time limit reached\n");
+                clocks = PCMCIA_BMT_LIMIT-1;
+        }
+
+        psst = clocks / 7;          /* setup time */
+        psht = clocks / 7;          /* hold time */
+        psl  = (clocks * 5) / 7;    /* strobe length */
+
+        psst += clocks - (psst + psht + psl);
+
+        reg =  psst << 12;
+        reg |= psl  << 7;
+        reg |= psht << 16;
+
+        return reg;
+}
+
+static int m8xx_get_status(struct pcmcia_socket *sock, unsigned int *value)
+{
+        int lsock = container_of(sock, struct socket_info, socket)->slot;
+        struct socket_info *s = &socket[lsock];
+        unsigned int pipr, reg;
+
+        pipr = in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pipr);
+
+        *value  = ((pipr & (M8XX_PCMCIA_CD1(lsock)
+                            | M8XX_PCMCIA_CD2(lsock))) == 0) ? SS_DETECT : 0;
+        *value |= (pipr & M8XX_PCMCIA_WP(lsock)) ? SS_WRPROT : 0;
+
+        if (s->state.flags & SS_IOCARD)
+                *value |= (pipr & M8XX_PCMCIA_BVD1(lsock)) ? SS_STSCHG : 0;
+        else {
+                *value |= (pipr & M8XX_PCMCIA_RDY(lsock)) ? SS_READY : 0;
+                *value |= (pipr & M8XX_PCMCIA_BVD1(lsock)) ? SS_BATDEAD : 0;
+                *value |= (pipr & M8XX_PCMCIA_BVD2(lsock)) ? SS_BATWARN : 0;
+        }
+
+        if (s->state.Vcc | s->state.Vpp)
+                *value |= SS_POWERON;
+
+        /*
+         * Voltage detection:
+         * This driver only supports 16-Bit pc-cards.
+         * Cardbus is not handled here.
+         *
+         * To determine what voltage to use we must read the VS1 and VS2 pin.
+         * Depending on what socket type is present,
+         * different combinations mean different things.
+         *
+         * Card Key  Socket Key   VS1   VS2   Card         Vcc for CIS parse
+         *
+         * 5V        5V, LV*      NC    NC    5V only       5V (if available)
+         *
+         * 5V        5V, LV*      GND   NC    5 or 3.3V     as low as possible
+         *
+         * 5V        5V, LV*      GND   GND   5, 3.3, x.xV  as low as possible
+         *
+         * LV*       5V            -     -    shall not fit into socket
+         *
+         * LV*       LV*          GND   NC    3.3V only     3.3V
+         *
+         * LV*       LV*          NC    GND   x.xV          x.xV (if avail.)
+         *
+         * LV*       LV*          GND   GND   3.3 or x.xV   as low as possible
+         *
+         * *LV means Low Voltage
+         *
+         *
+         * That gives us the following table:
+         *
+         * Socket    VS1  VS2   Voltage
+         *
+         * 5V        NC   NC    5V
+         * 5V        NC   GND   none (should not be possible)
+         * 5V        GND  NC    >= 3.3V
+         * 5V        GND  GND   >= x.xV
+         *
+         * LV        NC   NC    5V   (if available)
+         * LV        NC   GND   x.xV (if available)
+         * LV        GND  NC    3.3V
+         * LV        GND  GND   >= x.xV
+         *
+         * So, how do I determine if I have a 5V or a LV
+         * socket on my board?  Look at the socket!
+         *
+         *
+         * Socket with 5V key:
+         * ++--------------------------------------------+
+         * ||                                            |
+         * ||                                           ||
+         * ||                                           ||
+         * |                                             |
+         * +---------------------------------------------+
+         *
+         * Socket with LV key:
+         * ++--------------------------------------------+
+         * ||                                            |
+         * |                                            ||
+         * |                                            ||
+         * |                                             |
+         * +---------------------------------------------+
+         *
+         *
+         * With other words - LV only cards does not fit
+         * into the 5V socket!
+         */
+
+        /* read out VS1 and VS2 */
+
+        reg = (pipr & M8XX_PCMCIA_VS_MASK(lsock))
+                >> M8XX_PCMCIA_VS_SHIFT(lsock);
+
+        if(socket_get(lsock) == PCMCIA_SOCKET_KEY_LV) {
+                switch(reg) {
+                case 1:
+                        *value |= SS_3VCARD;
+                        break; /* GND, NC - 3.3V only */
+                case 2:
+                        *value |= SS_XVCARD;
+                        break; /* NC. GND - x.xV only */
+                };
+        }
+
+        dprintk("GetStatus(%d) = %#2.2x\n", lsock, *value);
+        return 0;
+}
+
+static int m8xx_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
+{
+        int lsock = container_of(sock, struct socket_info, socket)->slot;
+        *state = socket[lsock].state; /* copy the whole structure */
+
+        dprintk("GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
+              "io_irq %d, csc_mask %#2.2x\n", lsock, state->flags,
+              state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
+        return 0;
+}
+
+static int m8xx_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
+{
+        int lsock = container_of(sock, struct socket_info, socket)->slot;
+        struct socket_info *s = &socket[lsock];
+        struct event_table *e;
+        unsigned int reg;
+        unsigned long flags;
+
+        dprintk( "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
+              "io_irq %d, csc_mask %#2.2x)\n", lsock, state->flags,
+              state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
+
+        /* First, set voltage - bail out if invalid */
+        if(voltage_set(lsock, state->Vcc, state->Vpp))
+                return -EINVAL;
+
+        /* Take care of reset... */
+        if(state->flags & SS_RESET)
+                out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) |  M8XX_PGCRX_CXRESET); /* active high */
+        else
+                out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) & ~M8XX_PGCRX_CXRESET);
+
+        /* ... and output enable. */
+
+        /* The CxOE signal is connected to a 74541 on the ADS.
+           I guess most other boards used the ADS as a reference.
+           I tried to control the CxOE signal with SS_OUTPUT_ENA,
+           but the reset signal seems connected via the 541.
+           If the CxOE is left high are some signals tristated and
+           no pullups are present -> the cards act wierd.
+           So right now the buffers are enabled if the power is on. */
+
+        if(state->Vcc || state->Vpp)
+                out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) & ~M8XX_PGCRX_CXOE); /* active low */
+        else
+                out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) | M8XX_PGCRX_CXOE);
+
+        /*
+         * We'd better turn off interrupts before
+         * we mess with the events-table..
+         */
+
+        spin_lock_irqsave(&events_lock, flags);
+
+        /*
+         * Play around with the interrupt mask to be able to
+         * give the events the generic pcmcia driver wants us to.
+         */
+
+        e = &s->events[0];
+        reg = 0;
+
+        if(state->csc_mask & SS_DETECT) {
+                e->eventbit = SS_DETECT;
+                reg |= e->regbit = (M8XX_PCMCIA_CD2(lsock)
+                                    | M8XX_PCMCIA_CD1(lsock));
+                e++;
+        }
+        if(state->flags & SS_IOCARD) {
+                /*
+                 * I/O card
+                 */
+                if(state->csc_mask & SS_STSCHG) {
+                        e->eventbit = SS_STSCHG;
+                        reg |= e->regbit = M8XX_PCMCIA_BVD1(lsock);
+                        e++;
+                }
+                /*
+                 * If io_irq is non-zero we should enable irq.
+                 */
+                if(state->io_irq) {
+                        out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) | mk_int_int_mask(state->io_irq) << 24);
+                        /*
+                         * Strange thing here:
+                         * The manual does not tell us which interrupt
+                         * the sources generate.
+                         * Anyhow, I found out that RDY_L generates IREQLVL.
+                         *
+                         * We use level triggerd interrupts, and they don't
+                         * have to be cleared in PSCR in the interrupt handler.
+                         */
+                        reg |= M8XX_PCMCIA_RDY_L(lsock);
+                }
+                else
+                        out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) & 0x00ffffff);
+        }
+        else {
+                /*
+                 * Memory card
+                 */
+                if(state->csc_mask & SS_BATDEAD) {
+                        e->eventbit = SS_BATDEAD;
+                        reg |= e->regbit = M8XX_PCMCIA_BVD1(lsock);
+                        e++;
+                }
+                if(state->csc_mask & SS_BATWARN) {
+                        e->eventbit = SS_BATWARN;
+                        reg |= e->regbit = M8XX_PCMCIA_BVD2(lsock);
+                        e++;
+                }
+                /* What should I trigger on - low/high,raise,fall? */
+                if(state->csc_mask & SS_READY) {
+                        e->eventbit = SS_READY;
+                        reg |= e->regbit = 0; //??
+                        e++;
+                }
+        }
+
+        e->regbit = 0;  /* terminate list */
+
+        /*
+         * Clear the status changed .
+         * Port A and Port B share the same port.
+         * Writing ones will clear the bits.
+         */
+
+        out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pscr, reg);
+
+        /*
+         * Write the mask.
+         * Port A and Port B share the same port.
+         * Need for read-modify-write.
+         * Ones will enable the interrupt.
+         */
+
+        /*
+          reg |= ((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per
+          & M8XX_PCMCIA_MASK(lsock);
+        */
+
+        reg |= in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per) &
+                (M8XX_PCMCIA_MASK(0) | M8XX_PCMCIA_MASK(1));
+
+        out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per, reg);
+
+        spin_unlock_irqrestore(&events_lock, flags);
+
+        /* copy the struct and modify the copy */
+
+        s->state = *state;
+
+        return 0;
+}
+
+static int m8xx_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
+{
+        int lsock = container_of(sock, struct socket_info, socket)->slot;
+
+        struct socket_info *s = &socket[lsock];
+        struct pcmcia_win *w;
+        unsigned int reg, winnr;
+
+#define M8XX_SIZE (io->stop - io->start + 1)
+#define M8XX_BASE (PCMCIA_IO_WIN_BASE + io->start)
+
+        dprintk( "SetIOMap(%d, %d, %#2.2x, %d ns, "
+              "%#4.4x-%#4.4x)\n", lsock, io->map, io->flags,
+              io->speed, io->start, io->stop);
+
+        if ((io->map >= PCMCIA_IO_WIN_NO) || (io->start > 0xffff)
+            || (io->stop > 0xffff) || (io->stop < io->start))
+                return -EINVAL;
+
+        if((reg = m8xx_get_graycode(M8XX_SIZE)) == -1)
+                return -EINVAL;
+
+        if(io->flags & MAP_ACTIVE) {
+
+                dprintk( "io->flags & MAP_ACTIVE\n");
+
+                winnr = (PCMCIA_MEM_WIN_NO * PCMCIA_SOCKETS_NO)
+                        + (lsock * PCMCIA_IO_WIN_NO) + io->map;
+
+                /* setup registers */
+
+                w = (void *) &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pbr0;
+                w += winnr;
+
+                out_be32(&w->or, 0); /* turn off window first */
+                out_be32(&w->br, M8XX_BASE);
+
+                reg <<= 27;
+                reg |= M8XX_PCMCIA_POR_IO |(lsock << 2);
+
+                reg |= m8xx_get_speed(io->speed, 1);
+
+                if(io->flags & MAP_WRPROT)
+                        reg |= M8XX_PCMCIA_POR_WRPROT;
+
+                /*if(io->flags & (MAP_16BIT | MAP_AUTOSZ))*/
+                if(io->flags & MAP_16BIT)
+                        reg |= M8XX_PCMCIA_POR_16BIT;
+
+                if(io->flags & MAP_ACTIVE)
+                        reg |= M8XX_PCMCIA_POR_VALID;
+
+                out_be32(&w->or, reg);
+
+                dprintk("Socket %u: Mapped io window %u at %#8.8x, "
+                      "OR = %#8.8x.\n", lsock, io->map, w->br, w->or);
+        } else {
+                /* shutdown IO window */
+                winnr = (PCMCIA_MEM_WIN_NO * PCMCIA_SOCKETS_NO)
+                        + (lsock * PCMCIA_IO_WIN_NO) + io->map;
+
+                /* setup registers */
+
+                w = (void *) &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pbr0;
+                w += winnr;
+
+                out_be32(&w->or, 0); /* turn off window */
+                out_be32(&w->br, 0); /* turn off base address */
+
+                dprintk("Socket %u: Unmapped io window %u at %#8.8x, "
+                        "OR = %#8.8x.\n", lsock, io->map, w->br, w->or);
+        }
+
+        /* copy the struct and modify the copy */
+        s->io_win[io->map] = *io;
+        s->io_win[io->map].flags &= (MAP_WRPROT
+                                     | MAP_16BIT
+                                     | MAP_ACTIVE);
+        dprintk("SetIOMap exit\n");
+
+        return 0;
+}
+
+static int m8xx_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
+{
+        int lsock = container_of(sock, struct socket_info, socket)->slot;
+        struct socket_info *s = &socket[lsock];
+        struct pcmcia_win *w;
+        struct pccard_mem_map *old;
+        unsigned int reg, winnr;
+
+        dprintk( "SetMemMap(%d, %d, %#2.2x, %d ns, "
+              "%#5.5lx, %#5.5x)\n", lsock, mem->map, mem->flags,
+              mem->speed, mem->static_start, mem->card_start);
+
+        if ((mem->map >= PCMCIA_MEM_WIN_NO)
+//          || ((mem->s) >= PCMCIA_MEM_WIN_SIZE)
+            || (mem->card_start >= 0x04000000)
+            || (mem->static_start & 0xfff)                /* 4KByte resolution */
+            || (mem->card_start & 0xfff))
+                return -EINVAL;
+
+        if((reg = m8xx_get_graycode(PCMCIA_MEM_WIN_SIZE)) == -1) {
+                printk( "Cannot set size to 0x%08x.\n", PCMCIA_MEM_WIN_SIZE);
+                return -EINVAL;
+        }
+        reg <<= 27;
+
+        winnr = (lsock * PCMCIA_MEM_WIN_NO) + mem->map;
+
+        /* Setup the window in the pcmcia controller */
+
+        w = (void *) &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pbr0;
+        w += winnr;
+
+        reg |= lsock << 2;
+
+        reg |= m8xx_get_speed(mem->speed, 0);
+
+        if(mem->flags & MAP_ATTRIB)
+                reg |=  M8XX_PCMCIA_POR_ATTRMEM;
+
+        if(mem->flags & MAP_WRPROT)
+                reg |= M8XX_PCMCIA_POR_WRPROT;
+
+        if(mem->flags & MAP_16BIT)
+                reg |= M8XX_PCMCIA_POR_16BIT;
+
+        if(mem->flags & MAP_ACTIVE)
+                reg |= M8XX_PCMCIA_POR_VALID;
+
+        out_be32(&w->or, reg);
+
+        dprintk("Socket %u: Mapped memory window %u at %#8.8x, "
+              "OR = %#8.8x.\n", lsock, mem->map, w->br, w->or);
+
+        if(mem->flags & MAP_ACTIVE) {
+                /* get the new base address */
+                mem->static_start = PCMCIA_MEM_WIN_BASE +
+                        (PCMCIA_MEM_WIN_SIZE * winnr)
+                        + mem->card_start;
+        }
+
+        dprintk("SetMemMap(%d, %d, %#2.2x, %d ns, "
+              "%#5.5lx, %#5.5x)\n", lsock, mem->map, mem->flags,
+              mem->speed, mem->static_start, mem->card_start);
+
+        /* copy the struct and modify the copy */
+
+        old = &s->mem_win[mem->map];
+
+        *old = *mem;
+        old->flags &= (MAP_ATTRIB
+                       | MAP_WRPROT
+                       | MAP_16BIT
+                       | MAP_ACTIVE);
+
+        return 0;
+}
+
+static int m8xx_sock_init(struct pcmcia_socket *sock)
+{
+        int i;
+        pccard_io_map io = { 0, 0, 0, 0, 1 };
+        pccard_mem_map mem = { 0, 0, 0, 0, 0, 0 };
+
+        dprintk( "sock_init(%d)\n", s);
+
+        m8xx_set_socket(sock, &dead_socket);
+        for (i = 0; i < PCMCIA_IO_WIN_NO; i++) {
+                io.map = i;
+                m8xx_set_io_map(sock, &io);
+        }
+        for (i = 0; i < PCMCIA_MEM_WIN_NO; i++) {
+                mem.map = i;
+                m8xx_set_mem_map(sock, &mem);
+        }
+
+        return 0;
+
+}
+
+static int m8xx_suspend(struct pcmcia_socket *sock)
+{
+        return m8xx_set_socket(sock, &dead_socket);
+}
+
+static struct pccard_operations m8xx_services = {
+        .init   = m8xx_sock_init,
+        .suspend = m8xx_suspend,
+        .get_status = m8xx_get_status,
+        .get_socket = m8xx_get_socket,
+        .set_socket = m8xx_set_socket,
+        .set_io_map = m8xx_set_io_map,
+        .set_mem_map = m8xx_set_mem_map,
+};
+
+static int __init m8xx_init(void)
+{
+        struct pcmcia_win *w;
+        unsigned int i,m;
+
+        pcmcia_info("%s\n", version);
+
+        if (driver_register(&m8xx_driver))
+                return -1;
+
+        pcmcia_info(PCMCIA_BOARD_MSG " using " PCMCIA_SLOT_MSG
+                    " with IRQ %u.\n", pcmcia_schlvl);
+
+        /* Configure Status change interrupt */
+
+        if(request_irq(pcmcia_schlvl, m8xx_interrupt, 0,
+                          "m8xx_pcmcia", NULL)) {
+                pcmcia_error("Cannot allocate IRQ %u for SCHLVL!\n",
+                             pcmcia_schlvl);
+                return -1;
+        }
+
+        w = (void *) &((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pbr0;
+
+        out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_pscr,
+                M8XX_PCMCIA_MASK(0)| M8XX_PCMCIA_MASK(1));
+
+        out_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per,
+                in_be32(&((immap_t *)IMAP_ADDR)->im_pcmcia.pcmc_per) &
+                ~(M8XX_PCMCIA_MASK(0)| M8XX_PCMCIA_MASK(1)));
+
+/* connect interrupt and disable CxOE */
+
+        out_be32(M8XX_PGCRX(0), M8XX_PGCRX_CXOE | (mk_int_int_mask(pcmcia_schlvl) << 16));
+        out_be32(M8XX_PGCRX(1), M8XX_PGCRX_CXOE | (mk_int_int_mask(pcmcia_schlvl) << 16));
+
+/* intialize the fixed memory windows */
+
+        for(i = 0; i < PCMCIA_SOCKETS_NO; i++){
+                for(m = 0; m < PCMCIA_MEM_WIN_NO; m++) {
+                        out_be32(&w->br, PCMCIA_MEM_WIN_BASE +
+                                (PCMCIA_MEM_WIN_SIZE
+                                 * (m + i * PCMCIA_MEM_WIN_NO)));
+
+                        out_be32(&w->or, 0);  /* set to not valid */
+
+                        w++;
+                }
+        }
+
+/* turn off voltage */
+        voltage_set(0, 0, 0);
+        voltage_set(1, 0, 0);
+
+/* Enable external hardware */
+        hardware_enable(0);
+        hardware_enable(1);
+
+        platform_device_register(&m8xx_device);
+
+        for (i = 0 ; i < PCMCIA_SOCKETS_NO; i++) {
+                socket[i].slot = i;
+                socket[i].socket.owner = THIS_MODULE;
+                socket[i].socket.features = SS_CAP_PCCARD | SS_CAP_MEM_ALIGN | SS_CAP_STATIC_MAP;
+                socket[i].socket.irq_mask = 0x000;
+                socket[i].socket.map_size = 0x1000;
+                socket[i].socket.io_offset = 0;
+                socket[i].socket.pci_irq = i  ? 7 : 9;
+                socket[i].socket.ops = &m8xx_services;
+                socket[i].socket.resource_ops = &pccard_nonstatic_ops;
+                socket[i].socket.cb_dev = NULL;
+                socket[i].socket.dev.dev = &m8xx_device.dev;
+        }
+
+        for (i = 0; i < PCMCIA_SOCKETS_NO; i++)
+                pcmcia_register_socket(&socket[i].socket);
+
+        return 0;
+}
+
+static void __exit m8xx_exit(void)
+{
+        int i;
+
+        for (i = 0; i < PCMCIA_SOCKETS_NO; i++)
+                pcmcia_unregister_socket(&socket[i].socket);
+
+        m8xx_shutdown();
+
+        platform_device_unregister(&m8xx_device);
+        driver_unregister(&m8xx_driver);
+}
+
+module_init(m8xx_init);
+module_exit(m8xx_exit);
diff --git a/drivers/pcmcia/pxa2xx_sharpsl.c b/drivers/pcmcia/pxa2xx_sharpsl.c
index b54a8b8c0fca..fe5ea36e7de3 100644
--- a/drivers/pcmcia/pxa2xx_sharpsl.c
+++ b/drivers/pcmcia/pxa2xx_sharpsl.c
@@ -18,10 +18,15 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 
+#include <asm/mach-types.h>
 #include <asm/hardware.h>
 #include <asm/irq.h>
 #include <asm/hardware/scoop.h>
-#include <asm/arch/pxa-regs.h>
+#ifdef CONFIG_SA1100_COLLIE
+#include <asm/arch-sa1100/collie.h>
+#else
+#include <asm/arch-pxa/pxa-regs.h>
+#endif
 
 #include "soc_common.h"
 
@@ -38,6 +43,7 @@ static int sharpsl_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
 {
         int ret;
 
+#ifndef CONFIG_SA1100_COLLIE
         /*
          * Setup default state of GPIO outputs
          * before we enable them as outputs.
@@ -60,6 +66,7 @@ static int sharpsl_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
         pxa_gpio_mode(GPIO55_nPREG_MD);
         pxa_gpio_mode(GPIO56_nPWAIT_MD);
         pxa_gpio_mode(GPIO57_nIOIS16_MD);
+#endif
 
         /* Register interrupts */
         if (scoop_devs[skt->nr].cd_irq >= 0) {
@@ -213,12 +220,20 @@ static void sharpsl_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
         write_scoop_reg(scoop_devs[skt->nr].dev, SCOOP_IMR, 0x00C0);
         write_scoop_reg(scoop_devs[skt->nr].dev, SCOOP_MCR, 0x0101);
         scoop_devs[skt->nr].keep_vs = NO_KEEP_VS;
+
+        if (machine_is_collie())
+                /* We need to disable SS_OUTPUT_ENA here. */
+                write_scoop_reg(scoop_devs[skt->nr].dev, SCOOP_CPR, read_scoop_reg(scoop_devs[skt->nr].dev, SCOOP_CPR) & ~0x0080);
 }
 
 static void sharpsl_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
 {
         /* CF_BUS_OFF */
         sharpsl_pcmcia_init_reset(&scoop_devs[skt->nr]);
+
+        if (machine_is_collie())
+                /* We need to disable SS_OUTPUT_ENA here. */
+                write_scoop_reg(scoop_devs[skt->nr].dev, SCOOP_CPR, read_scoop_reg(scoop_devs[skt->nr].dev, SCOOP_CPR) & ~0x0080);
 }
 
 static struct pcmcia_low_level sharpsl_pcmcia_ops = {
@@ -235,6 +250,19 @@ static struct pcmcia_low_level sharpsl_pcmcia_ops = {
 
 static struct platform_device *sharpsl_pcmcia_device;
 
+#ifdef CONFIG_SA1100_COLLIE
+int __init pcmcia_collie_init(struct device *dev)
+{
+       int ret = -ENODEV;
+
+       if (machine_is_collie())
+               ret = sa11xx_drv_pcmcia_probe(dev, &sharpsl_pcmcia_ops, 0, 1);
+
+       return ret;
+}
+
+#else
+
 static int __init sharpsl_pcmcia_init(void)
 {
         int ret;
@@ -269,6 +297,7 @@ static void __exit sharpsl_pcmcia_exit(void)
 
 fs_initcall(sharpsl_pcmcia_init);
 module_exit(sharpsl_pcmcia_exit);
+#endif
 
 MODULE_DESCRIPTION("Sharp SL Series PCMCIA Support");
 MODULE_LICENSE("GPL");
diff --git a/drivers/pcmcia/rsrc_nonstatic.c b/drivers/pcmcia/rsrc_nonstatic.c
index fc87e7e2b6b8..00960a379b9c 100644
--- a/drivers/pcmcia/rsrc_nonstatic.c
+++ b/drivers/pcmcia/rsrc_nonstatic.c
@@ -779,7 +779,7 @@ static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
         if (!s->cb_dev || !s->cb_dev->bus)
                 return -ENODEV;
 
-#if defined(CONFIG_X86) || defined(CONFIG_X86_64)
+#if defined(CONFIG_X86)
         /* If this is the root bus, the risk of hitting
          * some strange system devices which aren't protected
          * by either ACPI resource tables or properly requested
diff --git a/drivers/pcmcia/sa1100_generic.c b/drivers/pcmcia/sa1100_generic.c
index 122fb29b1e34..6d441ec75c6a 100644
--- a/drivers/pcmcia/sa1100_generic.c
+++ b/drivers/pcmcia/sa1100_generic.c
@@ -39,8 +39,12 @@
 #include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 
+#include <asm/hardware/scoop.h>
+
 #include "sa1100_generic.h"
 
+int __init pcmcia_collie_init(struct device *dev);
+
 static int (*sa11x0_pcmcia_hw_init[])(struct device *dev) = {
 #ifdef CONFIG_SA1100_ASSABET
         pcmcia_assabet_init,
@@ -57,6 +61,9 @@ static int (*sa11x0_pcmcia_hw_init[])(struct device *dev) = {
 #ifdef CONFIG_SA1100_SIMPAD
         pcmcia_simpad_init,
 #endif
+#ifdef CONFIG_SA1100_COLLIE
+       pcmcia_collie_init,
+#endif
 };
 
 static int sa11x0_drv_pcmcia_probe(struct device *dev)
diff --git a/drivers/pnp/manager.c b/drivers/pnp/manager.c
index 94442ffd4aed..cbb2749db178 100644
--- a/drivers/pnp/manager.c
+++ b/drivers/pnp/manager.c
@@ -12,6 +12,8 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/pnp.h>
+#include <linux/slab.h>
+#include <linux/bitmap.h>
 #include "base.h"
 
 DECLARE_MUTEX(pnp_res_mutex);
diff --git a/drivers/pnp/pnpbios/rsparser.c b/drivers/pnp/pnpbios/rsparser.c
index b0ca65b68645..5e38cd7335f7 100644
--- a/drivers/pnp/pnpbios/rsparser.c
+++ b/drivers/pnp/pnpbios/rsparser.c
@@ -7,6 +7,8 @@
 #include <linux/ctype.h>
 #include <linux/pnp.h>
 #include <linux/pnpbios.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 #ifdef CONFIG_PCI
 #include <linux/pci.h>
diff --git a/drivers/s390/char/con3270.c b/drivers/s390/char/con3270.c
index fc7a213e591f..c570a9f6ce9c 100644
--- a/drivers/s390/char/con3270.c
+++ b/drivers/s390/char/con3270.c
@@ -213,6 +213,9 @@ con3270_update(struct con3270 *cp)
         struct string *s, *n;
         int rc;
 
+        if (cp->view.dev)
+                raw3270_activate_view(&cp->view);
+
         wrq = xchg(&cp->write, 0);
         if (!wrq) {
                 con3270_set_timer(cp, 1);
@@ -489,8 +492,6 @@ con3270_write(struct console *co, const char *str, unsigned int count)
         unsigned char c;
 
         cp = condev;
-        if (cp->view.dev)
-                raw3270_activate_view(&cp->view);
         spin_lock_irqsave(&cp->view.lock, flags);
         while (count-- > 0) {
                 c = *str++;
@@ -620,7 +621,7 @@ con3270_init(void)
                      (void (*)(unsigned long)) con3270_read_tasklet,
                      (unsigned long) condev->read);
 
-        raw3270_add_view(&condev->view, &con3270_fn, 0);
+        raw3270_add_view(&condev->view, &con3270_fn, 1);
 
         INIT_LIST_HEAD(&condev->freemem);
         for (i = 0; i < CON3270_STRING_PAGES; i++) {
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 60afcdcf91c2..735a7fcdeff5 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -33,8 +33,11 @@ struct fs3270 {
         int read_command;               /* ccw command to use for reads. */
         int write_command;              /* ccw command to use for writes. */
         int attention;                  /* Got attention. */
-        struct raw3270_request *clear;  /* single clear request. */
-        wait_queue_head_t attn_wait;    /* Attention wait queue. */
+        int active;                     /* Fullscreen view is active. */
+        struct raw3270_request *init;   /* single init request. */
+        wait_queue_head_t wait;         /* Init & attention wait queue. */
+        struct idal_buffer *rdbuf;      /* full-screen-deactivate buffer */
+        size_t rdbuf_size;              /* size of data returned by RDBUF */
 };
 
 static void
@@ -43,58 +46,172 @@ fs3270_wake_up(struct raw3270_request *rq, void *data)
         wake_up((wait_queue_head_t *) data);
 }
 
+static inline int
+fs3270_working(struct fs3270 *fp)
+{
+        /*
+         * The fullscreen view is in working order if the view
+         * has been activated AND the initial request is finished.
+         */
+        return fp->active && raw3270_request_final(fp->init);
+}
+
 static int
 fs3270_do_io(struct raw3270_view *view, struct raw3270_request *rq)
 {
-        wait_queue_head_t wq;
+        struct fs3270 *fp;
         int rc;
 
-        init_waitqueue_head(&wq);
+        fp = (struct fs3270 *) view;
         rq->callback = fs3270_wake_up;
-        rq->callback_data = &wq;
-        rc = raw3270_start(view, rq);
-        if (rc)
-                return rc;
-        /* Started sucessfully. Now wait for completion. */
-        wait_event(wq, raw3270_request_final(rq));
-        return rq->rc;
+        rq->callback_data = &fp->wait;
+
+        do {
+                if (!fs3270_working(fp)) {
+                        /* Fullscreen view isn't ready yet. */
+                        rc = wait_event_interruptible(fp->wait,
+                                                      fs3270_working(fp));
+                        if (rc != 0)
+                                break;
+                }
+                rc = raw3270_start(view, rq);
+                if (rc == 0) {
+                        /* Started sucessfully. Now wait for completion. */
+                        wait_event(fp->wait, raw3270_request_final(rq));
+                }
+        } while (rc == -EACCES);
+        return rc;
 }
 
+/*
+ * Switch to the fullscreen view.
+ */
 static void
 fs3270_reset_callback(struct raw3270_request *rq, void *data)
 {
+        struct fs3270 *fp;
+
+        fp = (struct fs3270 *) rq->view;
         raw3270_request_reset(rq);
+        wake_up(&fp->wait);
+}
+
+static void
+fs3270_restore_callback(struct raw3270_request *rq, void *data)
+{
+        struct fs3270 *fp;
+
+        fp = (struct fs3270 *) rq->view;
+        if (rq->rc != 0 || rq->rescnt != 0) {
+                if (fp->fs_pid)
+                        kill_proc(fp->fs_pid, SIGHUP, 1);
+        }
+        fp->rdbuf_size = 0;
+        raw3270_request_reset(rq);
+        wake_up(&fp->wait);
 }
 
-/*
- * Switch to the fullscreen view.
- */
 static int
 fs3270_activate(struct raw3270_view *view)
 {
         struct fs3270 *fp;
+        char *cp;
+        int rc;
 
         fp = (struct fs3270 *) view;
-        raw3270_request_set_cmd(fp->clear, TC_EWRITEA);
-        fp->clear->callback = fs3270_reset_callback;
-        return raw3270_start(view, fp->clear);
+
+        /* If an old init command is still running just return. */
+        if (!raw3270_request_final(fp->init))
+                return 0;
+
+        if (fp->rdbuf_size == 0) {
+                /* No saved buffer. Just clear the screen. */
+                raw3270_request_set_cmd(fp->init, TC_EWRITEA);
+                fp->init->callback = fs3270_reset_callback;
+        } else {
+                /* Restore fullscreen buffer saved by fs3270_deactivate. */
+                raw3270_request_set_cmd(fp->init, TC_EWRITEA);
+                raw3270_request_set_idal(fp->init, fp->rdbuf);
+                fp->init->ccw.count = fp->rdbuf_size;
+                cp = fp->rdbuf->data[0];
+                cp[0] = TW_KR;
+                cp[1] = TO_SBA;
+                cp[2] = cp[6];
+                cp[3] = cp[7];
+                cp[4] = TO_IC;
+                cp[5] = TO_SBA;
+                cp[6] = 0x40;
+                cp[7] = 0x40;
+                fp->init->rescnt = 0;
+                fp->init->callback = fs3270_restore_callback;
+        }
+        rc = fp->init->rc = raw3270_start_locked(view, fp->init);
+        if (rc)
+                fp->init->callback(fp->init, NULL);
+        else
+                fp->active = 1;
+        return rc;
 }
 
 /*
  * Shutdown fullscreen view.
  */
 static void
+fs3270_save_callback(struct raw3270_request *rq, void *data)
+{
+        struct fs3270 *fp;
+
+        fp = (struct fs3270 *) rq->view;
+
+        /* Correct idal buffer element 0 address. */
+        fp->rdbuf->data[0] -= 5;
+        fp->rdbuf->size += 5;
+
+        /*
+         * If the rdbuf command failed or the idal buffer is
+         * to small for the amount of data returned by the
+         * rdbuf command, then we have no choice but to send
+         * a SIGHUP to the application.
+         */
+        if (rq->rc != 0 || rq->rescnt == 0) {
+                if (fp->fs_pid)
+                        kill_proc(fp->fs_pid, SIGHUP, 1);
+                fp->rdbuf_size = 0;
+        } else
+                fp->rdbuf_size = fp->rdbuf->size - rq->rescnt;
+        raw3270_request_reset(rq);
+        wake_up(&fp->wait);
+}
+
+static void
 fs3270_deactivate(struct raw3270_view *view)
 {
-        // FIXME: is this a good idea? The user program using fullscreen 3270
-        // will die just because a console message appeared. On the other
-        // hand the fullscreen device is unoperational now.
         struct fs3270 *fp;
 
         fp = (struct fs3270 *) view;
-        if (fp->fs_pid != 0)
-                kill_proc(fp->fs_pid, SIGHUP, 1);
-        fp->fs_pid = 0;
+        fp->active = 0;
+
+        /* If an old init command is still running just return. */
+        if (!raw3270_request_final(fp->init))
+                return;
+
+        /* Prepare read-buffer request. */
+        raw3270_request_set_cmd(fp->init, TC_RDBUF);
+        /*
+         * Hackish: skip first 5 bytes of the idal buffer to make
+         * room for the TW_KR/TO_SBA/<address>/<address>/TO_IC sequence
+         * in the activation command.
+         */
+        fp->rdbuf->data[0] += 5;
+        fp->rdbuf->size -= 5;
+        raw3270_request_set_idal(fp->init, fp->rdbuf);
+        fp->init->rescnt = 0;
+        fp->init->callback = fs3270_save_callback;
+
+        /* Start I/O to read in the 3270 buffer. */
+        fp->init->rc = raw3270_start_locked(view, fp->init);
+        if (fp->init->rc)
+                fp->init->callback(fp->init, NULL);
 }
 
 static int
@@ -103,7 +220,7 @@ fs3270_irq(struct fs3270 *fp, struct raw3270_request *rq, struct irb *irb)
         /* Handle ATTN. Set indication and wake waiters for attention. */
         if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
                 fp->attention = 1;
-                wake_up(&fp->attn_wait);
+                wake_up(&fp->wait);
         }
 
         if (rq) {
@@ -125,7 +242,7 @@ fs3270_read(struct file *filp, char *data, size_t count, loff_t *off)
         struct fs3270 *fp;
         struct raw3270_request *rq;
         struct idal_buffer *ib;
-        int rc;
+        ssize_t rc;
         
         if (count == 0 || count > 65535)
                 return -EINVAL;
@@ -133,7 +250,7 @@ fs3270_read(struct file *filp, char *data, size_t count, loff_t *off)
         if (!fp)
                 return -ENODEV;
         ib = idal_buffer_alloc(count, 0);
-        if (!ib)
+        if (IS_ERR(ib))
                 return -ENOMEM;
         rq = raw3270_request_alloc(0);
         if (!IS_ERR(rq)) {
@@ -141,10 +258,19 @@ fs3270_read(struct file *filp, char *data, size_t count, loff_t *off)
                         fp->read_command = 6;
                 raw3270_request_set_cmd(rq, fp->read_command ? : 2);
                 raw3270_request_set_idal(rq, ib);
-                wait_event(fp->attn_wait, fp->attention);
-                rc = fs3270_do_io(&fp->view, rq);
-                if (rc == 0 && idal_buffer_to_user(ib, data, count))
-                        rc = -EFAULT;
+                rc = wait_event_interruptible(fp->wait, fp->attention);
+                fp->attention = 0;
+                if (rc == 0) {
+                        rc = fs3270_do_io(&fp->view, rq);
+                        if (rc == 0) {
+                                count -= rq->rescnt;
+                                if (idal_buffer_to_user(ib, data, count) != 0)
+                                        rc = -EFAULT;
+                                else
+                                        rc = count;
+
+                        }
+                }
                 raw3270_request_free(rq);
         } else
                 rc = PTR_ERR(rq);
@@ -162,13 +288,13 @@ fs3270_write(struct file *filp, const char *data, size_t count, loff_t *off)
         struct raw3270_request *rq;
         struct idal_buffer *ib;
         int write_command;
-        int rc;
+        ssize_t rc;
 
         fp = filp->private_data;
         if (!fp)
                 return -ENODEV;
         ib = idal_buffer_alloc(count, 0);
-        if (!ib)
+        if (IS_ERR(ib))
                 return -ENOMEM;
         rq = raw3270_request_alloc(0);
         if (!IS_ERR(rq)) {
@@ -179,6 +305,8 @@ fs3270_write(struct file *filp, const char *data, size_t count, loff_t *off)
                         raw3270_request_set_cmd(rq, write_command);
                         raw3270_request_set_idal(rq, ib);
                         rc = fs3270_do_io(&fp->view, rq);
+                        if (rc == 0)
+                                rc = count - rq->rescnt;
                 } else
                         rc = -EFAULT;
                 raw3270_request_free(rq);
@@ -232,7 +360,7 @@ fs3270_ioctl(struct inode *inode, struct file *filp,
 }
 
 /*
- * Allocate tty3270 structure.
+ * Allocate fs3270 structure.
  */
 static struct fs3270 *
 fs3270_alloc_view(void)
@@ -243,8 +371,8 @@ fs3270_alloc_view(void)
         if (!fp)
                 return ERR_PTR(-ENOMEM);
         memset(fp, 0, sizeof(struct fs3270));
-        fp->clear = raw3270_request_alloc(0);
-        if (!IS_ERR(fp->clear)) {
+        fp->init = raw3270_request_alloc(0);
+        if (IS_ERR(fp->init)) {
                 kfree(fp);
                 return ERR_PTR(-ENOMEM);
         }
@@ -252,12 +380,17 @@ fs3270_alloc_view(void)
 }
 
 /*
- * Free tty3270 structure.
+ * Free fs3270 structure.
  */
 static void
 fs3270_free_view(struct raw3270_view *view)
 {
-        raw3270_request_free(((struct fs3270 *) view)->clear);
+        struct fs3270 *fp;
+
+        fp = (struct fs3270 *) view;
+        if (fp->rdbuf)
+                idal_buffer_free(fp->rdbuf);
+        raw3270_request_free(((struct fs3270 *) view)->init);
         kfree(view);
 }
 
@@ -285,11 +418,20 @@ static int
 fs3270_open(struct inode *inode, struct file *filp)
 {
         struct fs3270 *fp;
+        struct idal_buffer *ib;
         int minor, rc;
 
         if (imajor(filp->f_dentry->d_inode) != IBM_FS3270_MAJOR)
                 return -ENODEV;
         minor = iminor(filp->f_dentry->d_inode);
+        /* Check for minor 0 multiplexer. */
+        if (minor == 0) {
+                if (!current->signal->tty)
+                        return -ENODEV;
+                if (current->signal->tty->driver->major != IBM_TTY3270_MAJOR)
+                        return -ENODEV;
+                minor = current->signal->tty->index + RAW3270_FIRSTMINOR;
+        }
         /* Check if some other program is already using fullscreen mode. */
         fp = (struct fs3270 *) raw3270_find_view(&fs3270_fn, minor);
         if (!IS_ERR(fp)) {
@@ -301,7 +443,7 @@ fs3270_open(struct inode *inode, struct file *filp)
         if (IS_ERR(fp))
                 return PTR_ERR(fp);
 
-        init_waitqueue_head(&fp->attn_wait);
+        init_waitqueue_head(&fp->wait);
         fp->fs_pid = current->pid;
         rc = raw3270_add_view(&fp->view, &fs3270_fn, minor);
         if (rc) {
@@ -309,8 +451,18 @@ fs3270_open(struct inode *inode, struct file *filp)
                 return rc;
         }
 
+        /* Allocate idal-buffer. */
+        ib = idal_buffer_alloc(2*fp->view.rows*fp->view.cols + 5, 0);
+        if (IS_ERR(ib)) {
+                raw3270_put_view(&fp->view);
+                raw3270_del_view(&fp->view);
+                return PTR_ERR(fp);
+        }
+        fp->rdbuf = ib;
+
         rc = raw3270_activate_view(&fp->view);
         if (rc) {
+                raw3270_put_view(&fp->view);
                 raw3270_del_view(&fp->view);
                 return rc;
         }
@@ -329,8 +481,12 @@ fs3270_close(struct inode *inode, struct file *filp)
 
         fp = filp->private_data;
         filp->private_data = 0;
-        if (fp)
+        if (fp) {
+                fp->fs_pid = 0;
+                raw3270_reset(&fp->view);
+                raw3270_put_view(&fp->view);
                 raw3270_del_view(&fp->view);
+        }
         return 0;
 }
 
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 328d9cbc56a3..d66946443dfc 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -25,6 +25,12 @@
 
 #include "raw3270.h"
 
+#include <linux/major.h>
+#include <linux/kdev_t.h>
+#include <linux/device.h>
+
+struct class *class3270;
+
 /* The main 3270 data structure. */
 struct raw3270 {
         struct list_head list;
@@ -41,6 +47,8 @@ struct raw3270 {
         struct timer_list timer;        /* Device timer. */
 
         unsigned char *ascebc;          /* ascii -> ebcdic table */
+        struct class_device *clttydev;  /* 3270-class tty device ptr */
+        struct class_device *cltubdev;  /* 3270-class tub device ptr */
 };
 
 /* raw3270->flags */
@@ -317,6 +325,22 @@ raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
 }
 
 int
+raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
+{
+        struct raw3270 *rp;
+        int rc;
+
+        rp = view->dev;
+        if (!rp || rp->view != view)
+                rc = -EACCES;
+        else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
+                rc = -ENODEV;
+        else
+                rc =  __raw3270_start(rp, view, rq);
+        return rc;
+}
+
+int
 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
 {
         struct raw3270 *rp;
@@ -744,6 +768,22 @@ raw3270_reset_device(struct raw3270 *rp)
         return rc;
 }
 
+int
+raw3270_reset(struct raw3270_view *view)
+{
+        struct raw3270 *rp;
+        int rc;
+
+        rp = view->dev;
+        if (!rp || rp->view != view)
+                rc = -EACCES;
+        else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
+                rc = -ENODEV;
+        else
+                rc = raw3270_reset_device(view->dev);
+        return rc;
+}
+
 /*
  * Setup new 3270 device.
  */
@@ -774,11 +814,12 @@ raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
 
         /*
          * Add device to list and find the smallest unused minor
-         * number for it.
+         * number for it. Note: there is no device with minor 0,
+         * see special case for fs3270.c:fs3270_open().
          */
         down(&raw3270_sem);
         /* Keep the list sorted. */
-        minor = 0;
+        minor = RAW3270_FIRSTMINOR;
         rp->minor = -1;
         list_for_each(l, &raw3270_devices) {
                 tmp = list_entry(l, struct raw3270, list);
@@ -789,7 +830,7 @@ raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
                 }
                 minor++;
         }
-        if (rp->minor == -1 && minor < RAW3270_MAXDEVS) {
+        if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
                 rp->minor = minor;
                 list_add_tail(&rp->list, &raw3270_devices);
         }
@@ -941,11 +982,12 @@ raw3270_deactivate_view(struct raw3270_view *view)
                 list_add_tail(&view->list, &rp->view_list);
                 /* Try to activate another view. */
                 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
-                        list_for_each_entry(view, &rp->view_list, list)
-                                if (view->fn->activate(view) == 0) {
-                                        rp->view = view;
+                        list_for_each_entry(view, &rp->view_list, list) {
+                                rp->view = view;
+                                if (view->fn->activate(view) == 0)
                                         break;
-                                }
+                                rp->view = 0;
+                        }
                 }
         }
         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
@@ -961,6 +1003,8 @@ raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
         struct raw3270 *rp;
         int rc;
 
+        if (minor <= 0)
+                return -ENODEV;
         down(&raw3270_sem);
         rc = -ENODEV;
         list_for_each_entry(rp, &raw3270_devices, list) {
@@ -976,7 +1020,7 @@ raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
                         view->cols = rp->cols;
                         view->ascebc = rp->ascebc;
                         spin_lock_init(&view->lock);
-                        list_add_tail(&view->list, &rp->view_list);
+                        list_add(&view->list, &rp->view_list);
                         rc = 0;
                 }
                 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
@@ -1039,7 +1083,7 @@ raw3270_del_view(struct raw3270_view *view)
         if (!rp->view && test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
                 /* Try to activate another view. */
                 list_for_each_entry(nv, &rp->view_list, list) {
-                        if (nv->fn->activate(view) == 0) {
+                        if (nv->fn->activate(nv) == 0) {
                                 rp->view = nv;
                                 break;
                         }
@@ -1063,6 +1107,12 @@ raw3270_delete_device(struct raw3270 *rp)
 
         /* Remove from device chain. */
         down(&raw3270_sem);
+        if (rp->clttydev)
+                class_device_destroy(class3270,
+                                     MKDEV(IBM_TTY3270_MAJOR, rp->minor));
+        if (rp->cltubdev)
+                class_device_destroy(class3270,
+                                     MKDEV(IBM_FS3270_MAJOR, rp->minor));
         list_del_init(&rp->list);
         up(&raw3270_sem);
 
@@ -1129,6 +1179,16 @@ raw3270_create_attributes(struct raw3270 *rp)
 {
         //FIXME: check return code
         sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
+        rp->clttydev =
+                class_device_create(class3270,
+                                    MKDEV(IBM_TTY3270_MAJOR, rp->minor),
+                                    &rp->cdev->dev, "tty%s",
+                                    rp->cdev->dev.bus_id);
+        rp->cltubdev =
+                class_device_create(class3270,
+                                    MKDEV(IBM_FS3270_MAJOR, rp->minor),
+                                    &rp->cdev->dev, "tub%s",
+                                    rp->cdev->dev.bus_id);
 }
 
 /*
@@ -1189,13 +1249,13 @@ raw3270_set_online (struct ccw_device *cdev)
                 return PTR_ERR(rp);
         rc = raw3270_reset_device(rp);
         if (rc)
-                return rc;
+                goto failure;
         rc = raw3270_size_device(rp);
         if (rc)
-                return rc;
+                goto failure;
         rc = raw3270_reset_device(rp);
         if (rc)
-                return rc;
+                goto failure;
         raw3270_create_attributes(rp);
         set_bit(RAW3270_FLAGS_READY, &rp->flags);
         down(&raw3270_sem);
@@ -1203,6 +1263,10 @@ raw3270_set_online (struct ccw_device *cdev)
                 np->notifier(rp->minor, 1);
         up(&raw3270_sem);
         return 0;
+
+failure:
+        raw3270_delete_device(rp);
+        return rc;
 }
 
 /*
@@ -1217,6 +1281,14 @@ raw3270_remove (struct ccw_device *cdev)
         struct raw3270_notifier *np;
 
         rp = cdev->dev.driver_data;
+        /*
+         * _remove is the opposite of _probe; it's probe that
+         * should set up rp.  raw3270_remove gets entered for
+         * devices even if they haven't been varied online.
+         * Thus, rp may validly be NULL here.
+         */
+        if (rp == NULL)
+                return;
         clear_bit(RAW3270_FLAGS_READY, &rp->flags);
 
         sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
@@ -1301,6 +1373,7 @@ raw3270_init(void)
         if (rc == 0) {
                 /* Create attributes for early (= console) device. */
                 down(&raw3270_sem);
+                class3270 = class_create(THIS_MODULE, "3270");
                 list_for_each_entry(rp, &raw3270_devices, list) {
                         get_device(&rp->cdev->dev);
                         raw3270_create_attributes(rp);
@@ -1314,6 +1387,7 @@ static void
 raw3270_exit(void)
 {
         ccw_driver_unregister(&raw3270_ccw_driver);
+        class_destroy(class3270);
 }
 
 MODULE_LICENSE("GPL");
@@ -1335,7 +1409,9 @@ EXPORT_SYMBOL(raw3270_find_view);
 EXPORT_SYMBOL(raw3270_activate_view);
 EXPORT_SYMBOL(raw3270_deactivate_view);
 EXPORT_SYMBOL(raw3270_start);
+EXPORT_SYMBOL(raw3270_start_locked);
 EXPORT_SYMBOL(raw3270_start_irq);
+EXPORT_SYMBOL(raw3270_reset);
 EXPORT_SYMBOL(raw3270_register_notifier);
 EXPORT_SYMBOL(raw3270_unregister_notifier);
 EXPORT_SYMBOL(raw3270_wait_queue);
diff --git a/drivers/s390/char/raw3270.h b/drivers/s390/char/raw3270.h
index ed5d4eb9f623..b635bf8e7775 100644
--- a/drivers/s390/char/raw3270.h
+++ b/drivers/s390/char/raw3270.h
@@ -21,6 +21,7 @@
 
 /* Local Channel Commands */
 #define TC_WRITE        0x01            /* Write */
+#define TC_RDBUF        0x02            /* Read Buffer */
 #define TC_EWRITE       0x05            /* Erase write */
 #define TC_READMOD      0x06            /* Read modified */
 #define TC_EWRITEA      0x0d            /* Erase write alternate */
@@ -76,7 +77,8 @@
 #define TW_KR           0xc2            /* Keyboard restore */
 #define TW_PLUSALARM    0x04            /* Add this bit for alarm */
 
-#define RAW3270_MAXDEVS 256
+#define RAW3270_FIRSTMINOR      1       /* First minor number */
+#define RAW3270_MAXDEVS         255     /* Max number of 3270 devices */
 
 /* For TUBGETMOD and TUBSETMOD. Should include. */
 struct raw3270_iocb {
@@ -166,7 +168,10 @@ void raw3270_del_view(struct raw3270_view *);
 void raw3270_deactivate_view(struct raw3270_view *);
 struct raw3270_view *raw3270_find_view(struct raw3270_fn *, int);
 int raw3270_start(struct raw3270_view *, struct raw3270_request *);
+int raw3270_start_locked(struct raw3270_view *, struct raw3270_request *);
 int raw3270_start_irq(struct raw3270_view *, struct raw3270_request *);
+int raw3270_reset(struct raw3270_view *);
+struct raw3270_view *raw3270_view(struct raw3270_view *);
 
 /* Reference count inliner for view structures. */
 static inline void
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 7db5ebce7f0f..4b9069370388 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -653,18 +653,12 @@ tty3270_activate(struct raw3270_view *view)
         tp->update_flags = TTY_UPDATE_ALL;
         tty3270_set_timer(tp, 1);
         spin_unlock_irqrestore(&tp->view.lock, flags);
-        start_tty(tp->tty);
         return 0;
 }
 
 static void
 tty3270_deactivate(struct raw3270_view *view)
 {
-        struct tty3270 *tp;
-
-        tp = (struct tty3270 *) view;
-        if (tp && tp->tty)
-                stop_tty(tp->tty);
 }
 
 static int
@@ -716,13 +710,13 @@ tty3270_alloc_view(void)
                                   tp->freemem_pages[pages], PAGE_SIZE);
         }
         tp->write = raw3270_request_alloc(TTY3270_OUTPUT_BUFFER_SIZE);
-        if (!tp->write)
+        if (IS_ERR(tp->write))
                 goto out_pages;
         tp->read = raw3270_request_alloc(0);
-        if (!tp->read)
+        if (IS_ERR(tp->read))
                 goto out_write;
         tp->kreset = raw3270_request_alloc(1);
-        if (!tp->kreset)
+        if (IS_ERR(tp->kreset))
                 goto out_read;
         tp->kbd = kbd_alloc();
         if (!tp->kbd)
@@ -845,7 +839,8 @@ tty3270_del_views(void)
         int i;
 
         for (i = 0; i < tty3270_max_index; i++) {
-                tp = (struct tty3270 *) raw3270_find_view(&tty3270_fn, i);
+                tp = (struct tty3270 *)
+                        raw3270_find_view(&tty3270_fn, i + RAW3270_FIRSTMINOR);
                 if (!IS_ERR(tp))
                         raw3270_del_view(&tp->view);
         }
@@ -871,7 +866,9 @@ tty3270_open(struct tty_struct *tty, struct file * filp)
         if (tty->count > 1)
                 return 0;
         /* Check if the tty3270 is already there. */
-        tp = (struct tty3270 *) raw3270_find_view(&tty3270_fn, tty->index);
+        tp = (struct tty3270 *)
+                raw3270_find_view(&tty3270_fn,
+                                  tty->index + RAW3270_FIRSTMINOR);
         if (!IS_ERR(tp)) {
                 tty->driver_data = tp;
                 tty->winsize.ws_row = tp->view.rows - 2;
@@ -903,7 +900,8 @@ tty3270_open(struct tty_struct *tty, struct file * filp)
                      (void (*)(unsigned long)) tty3270_read_tasklet,
                      (unsigned long) tp->read);
 
-        rc = raw3270_add_view(&tp->view, &tty3270_fn, tty->index);
+        rc = raw3270_add_view(&tp->view, &tty3270_fn,
+                              tty->index + RAW3270_FIRSTMINOR);
         if (rc) {
                 tty3270_free_view(tp);
                 return rc;
@@ -911,8 +909,8 @@ tty3270_open(struct tty_struct *tty, struct file * filp)
 
         rc = tty3270_alloc_screen(tp);
         if (rc) {
-                raw3270_del_view(&tp->view);
                 raw3270_put_view(&tp->view);
+                raw3270_del_view(&tp->view);
                 return rc;
         }
 
@@ -1780,7 +1778,7 @@ tty3270_init(void)
         struct tty_driver *driver;
         int ret;
 
-        driver = alloc_tty_driver(256);
+        driver = alloc_tty_driver(RAW3270_MAXDEVS);
         if (!driver)
                 return -ENOMEM;
 
@@ -1794,6 +1792,7 @@ tty3270_init(void)
         driver->driver_name = "ttyTUB";
         driver->name = "ttyTUB";
         driver->major = IBM_TTY3270_MAJOR;
+        driver->minor_start = RAW3270_FIRSTMINOR;
         driver->type = TTY_DRIVER_TYPE_SYSTEM;
         driver->subtype = SYSTEM_TYPE_TTY;
         driver->init_termios = tty_std_termios;
diff --git a/drivers/s390/char/vmlogrdr.c b/drivers/s390/char/vmlogrdr.c
index a107fec4457a..b2d75de144c6 100644
--- a/drivers/s390/char/vmlogrdr.c
+++ b/drivers/s390/char/vmlogrdr.c
@@ -787,8 +787,8 @@ vmlogrdr_register_device(struct vmlogrdr_priv_t *priv) {
                 return ret;
         }
         priv->class_device = class_device_create(
-                                NULL,
                                 vmlogrdr_class,
+                                NULL,
                                 MKDEV(vmlogrdr_major, priv->minor_num),
                                 dev,
                                 "%s", dev->bus_id );
diff --git a/drivers/s390/cio/cmf.c b/drivers/s390/cio/cmf.c
index 8cc4f1a940dc..c05b069c2996 100644
--- a/drivers/s390/cio/cmf.c
+++ b/drivers/s390/cio/cmf.c
@@ -30,10 +30,13 @@
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
+#include <linux/timex.h>        /* get_clock() */
 
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
 #include <asm/cmb.h>
+#include <asm/div64.h>
 
 #include "cio.h"
 #include "css.h"
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 9adc11e8b8bc..811c9d150637 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -22,6 +22,7 @@
 
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
+#include <asm/param.h>          /* HZ */
 
 #include "cio.h"
 #include "css.h"
@@ -252,6 +253,23 @@ cutype_show (struct device *dev, struct device_attribute *attr, char *buf)
 }
 
 static ssize_t
+modalias_show (struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct ccw_device *cdev = to_ccwdev(dev);
+        struct ccw_device_id *id = &(cdev->id);
+        int ret;
+
+        ret = sprintf(buf, "ccw:t%04Xm%02x",
+                        id->cu_type, id->cu_model);
+        if (id->dev_type != 0)
+                ret += sprintf(buf + ret, "dt%04Xdm%02X\n",
+                                id->dev_type, id->dev_model);
+        else
+                ret += sprintf(buf + ret, "dtdm\n");
+        return ret;
+}
+
+static ssize_t
 online_show (struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct ccw_device *cdev = to_ccwdev(dev);
@@ -448,6 +466,7 @@ static DEVICE_ATTR(chpids, 0444, chpids_show, NULL);
 static DEVICE_ATTR(pimpampom, 0444, pimpampom_show, NULL);
 static DEVICE_ATTR(devtype, 0444, devtype_show, NULL);
 static DEVICE_ATTR(cutype, 0444, cutype_show, NULL);
+static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
 static DEVICE_ATTR(online, 0644, online_show, online_store);
 extern struct device_attribute dev_attr_cmb_enable;
 static DEVICE_ATTR(availability, 0444, available_show, NULL);
@@ -471,6 +490,7 @@ subchannel_add_files (struct device *dev)
 static struct attribute * ccwdev_attrs[] = {
         &dev_attr_devtype.attr,
         &dev_attr_cutype.attr,
+        &dev_attr_modalias.attr,
         &dev_attr_online.attr,
         &dev_attr_cmb_enable.attr,
         &dev_attr_availability.attr,
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index fbe4202a3f6f..c1c89f4fd4e3 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -11,6 +11,8 @@
 #include <linux/module.h>
 #include <linux/config.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/string.h>
 
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index fe8187d6f58b..e2a5657d5fdb 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -41,6 +41,7 @@
 #include <linux/interrupt.h>
 #include <linux/sched.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -192,7 +193,6 @@ static void ahci_port_stop(struct ata_port *ap);
 static void ahci_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 static void ahci_qc_prep(struct ata_queued_cmd *qc);
 static u8 ahci_check_status(struct ata_port *ap);
-static u8 ahci_check_err(struct ata_port *ap);
 static inline int ahci_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 static void ahci_remove_one (struct pci_dev *pdev);
 
@@ -221,7 +221,6 @@ static const struct ata_port_operations ahci_ops = {
 
         .check_status           = ahci_check_status,
         .check_altstatus        = ahci_check_status,
-        .check_err              = ahci_check_err,
         .dev_select             = ata_noop_dev_select,
 
         .tf_read                = ahci_tf_read,
@@ -458,13 +457,6 @@ static u8 ahci_check_status(struct ata_port *ap)
         return readl(mmio + PORT_TFDATA) & 0xFF;
 }
 
-static u8 ahci_check_err(struct ata_port *ap)
-{
-        void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
-
-        return (readl(mmio + PORT_TFDATA) >> 8) & 0xFF;
-}
-
 static void ahci_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 {
         struct ahci_port_priv *pp = ap->private_data;
@@ -609,7 +601,7 @@ static void ahci_eng_timeout(struct ata_port *ap)
                  * not being called from the SCSI EH.
                  */
                 qc->scsidone = scsi_finish_command;
-                ata_qc_complete(qc, ATA_ERR);
+                ata_qc_complete(qc, AC_ERR_OTHER);
         }
 
         spin_unlock_irqrestore(&host_set->lock, flags);
@@ -638,7 +630,7 @@ static inline int ahci_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         if (status & PORT_IRQ_FATAL) {
                 ahci_intr_error(ap, status);
                 if (qc)
-                        ata_qc_complete(qc, ATA_ERR);
+                        ata_qc_complete(qc, AC_ERR_OTHER);
         }
 
         return 1;
@@ -683,10 +675,10 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
                         if (!ahci_host_intr(ap, qc))
                                 if (ata_ratelimit()) {
                                         struct pci_dev *pdev =
-                                          to_pci_dev(ap->host_set->dev);
-                                        printk(KERN_WARNING
-                                          "ahci(%s): unhandled interrupt on port %u\n",
-                                          pci_name(pdev), i);
+                                                to_pci_dev(ap->host_set->dev);
+                                        dev_printk(KERN_WARNING, &pdev->dev,
+                                          "unhandled interrupt on port %u\n",
+                                          i);
                                 }
 
                         VPRINTK("port %u\n", i);
@@ -694,10 +686,9 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
                         VPRINTK("port %u (no irq)\n", i);
                         if (ata_ratelimit()) {
                                 struct pci_dev *pdev =
-                                  to_pci_dev(ap->host_set->dev);
-                                printk(KERN_WARNING
-                                  "ahci(%s): interrupt on disabled port %u\n",
-                                  pci_name(pdev), i);
+                                        to_pci_dev(ap->host_set->dev);
+                                dev_printk(KERN_WARNING, &pdev->dev,
+                                        "interrupt on disabled port %u\n", i);
                         }
                 }
 
@@ -769,8 +760,8 @@ static int ahci_host_init(struct ata_probe_ent *probe_ent)
 
         tmp = readl(mmio + HOST_CTL);
         if (tmp & HOST_RESET) {
-                printk(KERN_ERR DRV_NAME "(%s): controller reset failed (0x%x)\n",
-                        pci_name(pdev), tmp);
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "controller reset failed (0x%x)\n", tmp);
                 return -EIO;
         }
 
@@ -798,22 +789,22 @@ static int ahci_host_init(struct ata_probe_ent *probe_ent)
                 if (rc) {
                         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                         if (rc) {
-                                printk(KERN_ERR DRV_NAME "(%s): 64-bit DMA enable failed\n",
-                                        pci_name(pdev));
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "64-bit DMA enable failed\n");
                                 return rc;
                         }
                 }
         } else {
                 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME "(%s): 32-bit DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "32-bit DMA enable failed\n");
                         return rc;
                 }
                 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME "(%s): 32-bit consistent DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "32-bit consistent DMA enable failed\n");
                         return rc;
                 }
         }
@@ -916,10 +907,10 @@ static void ahci_print_info(struct ata_probe_ent *probe_ent)
         else
                 scc_s = "unknown";
 
-        printk(KERN_INFO DRV_NAME "(%s) AHCI %02x%02x.%02x%02x "
+        dev_printk(KERN_INFO, &pdev->dev,
+                "AHCI %02x%02x.%02x%02x "
                 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
                 ,
-                pci_name(pdev),
 
                 (vers >> 24) & 0xff,
                 (vers >> 16) & 0xff,
@@ -932,11 +923,11 @@ static void ahci_print_info(struct ata_probe_ent *probe_ent)
                 impl,
                 scc_s);
 
-        printk(KERN_INFO DRV_NAME "(%s) flags: "
+        dev_printk(KERN_INFO, &pdev->dev,
+                "flags: "
                 "%s%s%s%s%s%s"
                 "%s%s%s%s%s%s%s\n"
                 ,
-                pci_name(pdev),
 
                 cap & (1 << 31) ? "64bit " : "",
                 cap & (1 << 30) ? "ncq " : "",
@@ -969,7 +960,7 @@ static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         VPRINTK("ENTER\n");
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/arm/scsi.h b/drivers/scsi/arm/scsi.h
index 48e1c4d9738b..19937640e2e7 100644
--- a/drivers/scsi/arm/scsi.h
+++ b/drivers/scsi/arm/scsi.h
@@ -10,6 +10,8 @@
  *  Commonly used scsi driver functions.
  */
 
+#include <linux/scatterlist.h>
+
 #define BELT_AND_BRACES
 
 /*
@@ -22,9 +24,7 @@ static inline int copy_SCp_to_sg(struct scatterlist *sg, Scsi_Pointer *SCp, int
 
         BUG_ON(bufs + 1 > max);
 
-        sg->page   = virt_to_page(SCp->ptr);
-        sg->offset = offset_in_page(SCp->ptr);
-        sg->length = SCp->this_residual;
+        sg_set_buf(sg, SCp->ptr, SCp->this_residual);
 
         if (bufs)
                 memcpy(sg + 1, SCp->buffer + 1,
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index be021478f416..7f8aa1b552ce 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -45,6 +45,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -621,18 +622,19 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version;
         struct ata_port_info *port_info[2];
-        unsigned int combined = 0, n_ports = 1;
+        unsigned int combined = 0;
         unsigned int pata_chan = 0, sata_chan = 0;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "version " DRV_VERSION "\n");
 
         /* no hotplugging support (FIXME) */
         if (!in_module_init)
                 return -ENODEV;
 
         port_info[0] = &piix_port_info[ent->driver_data];
-        port_info[1] = NULL;
+        port_info[1] = &piix_port_info[ent->driver_data];
 
         if (port_info[0]->host_flags & PIIX_FLAG_AHCI) {
                 u8 tmp;
@@ -670,12 +672,13 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 port_info[sata_chan] = &piix_port_info[ent->driver_data];
                 port_info[sata_chan]->host_flags |= ATA_FLAG_SLAVE_POSS;
                 port_info[pata_chan] = &piix_port_info[ich5_pata];
-                n_ports++;
 
-                printk(KERN_WARNING DRV_NAME ": combined mode detected\n");
+                dev_printk(KERN_WARNING, &pdev->dev,
+                           "combined mode detected (p=%u, s=%u)\n",
+                           pata_chan, sata_chan);
         }
 
-        return ata_pci_init_one(pdev, port_info, n_ports);
+        return ata_pci_init_one(pdev, port_info, 2);
 }
 
 static int __init piix_init(void)
diff --git a/drivers/scsi/dec_esp.c b/drivers/scsi/dec_esp.c
index 315f95a0d6c0..4f39890b44ac 100644
--- a/drivers/scsi/dec_esp.c
+++ b/drivers/scsi/dec_esp.c
@@ -228,7 +228,7 @@ static int dec_esp_detect(Scsi_Host_Template * tpnt)
                         mem_start = get_tc_base_addr(slot);
 
                         /* Store base addr into esp struct */
-                        esp->slot = PHYSADDR(mem_start);
+                        esp->slot = CPHYSADDR(mem_start);
 
                         esp->dregs = 0;
                         esp->eregs = (struct ESP_regs *) (mem_start + DEC_SCSI_SREG);
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index ff25210b00ba..822b9fa706f3 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1543,13 +1543,16 @@ static struct vio_device_id ibmvscsi_device_table[] __devinitdata = {
         {"vscsi", "IBM,v-scsi"},
         { "", "" }
 };
-
 MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table);
+
 static struct vio_driver ibmvscsi_driver = {
-        .name = "ibmvscsi",
         .id_table = ibmvscsi_device_table,
         .probe = ibmvscsi_probe,
-        .remove = ibmvscsi_remove
+        .remove = ibmvscsi_remove,
+        .driver = {
+                .name = "ibmvscsi",
+                .owner = THIS_MODULE,
+        }
 };
 
 int __init ibmvscsi_module_init(void)
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 3d62c9bcbff7..00d6a6657ebc 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -180,19 +180,12 @@ static void idescsi_input_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigne
                         return;
                 }
                 count = min(pc->sg->length - pc->b_count, bcount);
-                if (PageHighMem(pc->sg->page)) {
-                        unsigned long flags;
-
-                        local_irq_save(flags);
-                        buf = kmap_atomic(pc->sg->page, KM_IRQ0) + pc->sg->offset;
-                        drive->hwif->atapi_input_bytes(drive, buf + pc->b_count, count);
-                        kunmap_atomic(buf - pc->sg->offset, KM_IRQ0);
-                        local_irq_restore(flags);
-                } else {
-                        buf = page_address(pc->sg->page) + pc->sg->offset;
-                        drive->hwif->atapi_input_bytes(drive, buf + pc->b_count, count);
-                }
-                bcount -= count; pc->b_count += count;
+                buf = kmap_atomic(pc->sg->page, KM_IRQ0);
+                drive->hwif->atapi_input_bytes(drive,
+                                buf + pc->b_count + pc->sg->offset, count);
+                kunmap_atomic(buf, KM_IRQ0);
+                bcount -= count;
+                pc->b_count += count;
                 if (pc->b_count == pc->sg->length) {
                         pc->sg++;
                         pc->b_count = 0;
@@ -212,19 +205,12 @@ static void idescsi_output_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsign
                         return;
                 }
                 count = min(pc->sg->length - pc->b_count, bcount);
-                if (PageHighMem(pc->sg->page)) {
-                        unsigned long flags;
-
-                        local_irq_save(flags);
-                        buf = kmap_atomic(pc->sg->page, KM_IRQ0) + pc->sg->offset;
-                        drive->hwif->atapi_output_bytes(drive, buf + pc->b_count, count);
-                        kunmap_atomic(buf - pc->sg->offset, KM_IRQ0);
-                        local_irq_restore(flags);
-                } else {
-                        buf = page_address(pc->sg->page) + pc->sg->offset;
-                        drive->hwif->atapi_output_bytes(drive, buf + pc->b_count, count);
-                }
-                bcount -= count; pc->b_count += count;
+                buf = kmap_atomic(pc->sg->page, KM_IRQ0);
+                drive->hwif->atapi_output_bytes(drive,
+                                buf + pc->b_count + pc->sg->offset, count);
+                kunmap_atomic(buf, KM_IRQ0);
+                bcount -= count;
+                pc->b_count += count;
                 if (pc->b_count == pc->sg->length) {
                         pc->sg++;
                         pc->b_count = 0;
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index f53d7b8ac33f..8be7dc0b47b8 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -49,6 +49,7 @@
 #include <linux/suspend.h>
 #include <linux/workqueue.h>
 #include <linux/jiffies.h>
+#include <linux/scatterlist.h>
 #include <scsi/scsi.h>
 #include "scsi.h"
 #include "scsi_priv.h"
@@ -370,6 +371,8 @@ static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
 
+        tf->command = ata_check_status(ap);
+        tf->feature = inb(ioaddr->error_addr);
         tf->nsect = inb(ioaddr->nsect_addr);
         tf->lbal = inb(ioaddr->lbal_addr);
         tf->lbam = inb(ioaddr->lbam_addr);
@@ -402,6 +405,8 @@ static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
 
+        tf->command = ata_check_status(ap);
+        tf->feature = readb((void __iomem *)ioaddr->error_addr);
         tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
         tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
         tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
@@ -522,30 +527,6 @@ u8 ata_altstatus(struct ata_port *ap)
 
 
 /**
- *      ata_chk_err - Read device error reg
- *      @ap: port where the device is
- *
- *      Reads ATA taskfile error register for
- *      currently-selected device and return its value.
- *
- *      Note: may NOT be used as the check_err() entry in
- *      ata_port_operations.
- *
- *      LOCKING:
- *      Inherited from caller.
- */
-u8 ata_chk_err(struct ata_port *ap)
-{
-        if (ap->ops->check_err)
-                return ap->ops->check_err(ap);
-
-        if (ap->flags & ATA_FLAG_MMIO) {
-                return readb((void __iomem *) ap->ioaddr.error_addr);
-        }
-        return inb(ap->ioaddr.error_addr);
-}
-
-/**
  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
  *      @tf: Taskfile to convert
  *      @fis: Buffer into which data will output
@@ -897,8 +878,8 @@ static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
 
         memset(&tf, 0, sizeof(tf));
 
-        err = ata_chk_err(ap);
         ap->ops->tf_read(ap, &tf);
+        err = tf.feature;
 
         dev->class = ATA_DEV_NONE;
 
@@ -1135,7 +1116,6 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device)
         unsigned int major_version;
         u16 tmp;
         unsigned long xfer_modes;
-        u8 status;
         unsigned int using_edd;
         DECLARE_COMPLETION(wait);
         struct ata_queued_cmd *qc;
@@ -1189,8 +1169,11 @@ retry:
         else
                 wait_for_completion(&wait);
 
-        status = ata_chk_status(ap);
-        if (status & ATA_ERR) {
+        spin_lock_irqsave(&ap->host_set->lock, flags);
+        ap->ops->tf_read(ap, &qc->tf);
+        spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+        if (qc->tf.command & ATA_ERR) {
                 /*
                  * arg!  EDD works for all test cases, but seems to return
                  * the ATA signature for some ATAPI devices.  Until the
@@ -1203,7 +1186,7 @@ retry:
                  * to have this problem.
                  */
                 if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
-                        u8 err = ata_chk_err(ap);
+                        u8 err = qc->tf.feature;
                         if (err & ATA_ABORTED) {
                                 dev->class = ATA_DEV_ATAPI;
                                 qc->cursg = 0;
@@ -2572,19 +2555,12 @@ void ata_qc_prep(struct ata_queued_cmd *qc)
 
 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
 {
-        struct scatterlist *sg;
-
         qc->flags |= ATA_QCFLAG_SINGLE;
 
-        memset(&qc->sgent, 0, sizeof(qc->sgent));
         qc->sg = &qc->sgent;
         qc->n_elem = 1;
         qc->buf_virt = buf;
-
-        sg = qc->sg;
-        sg->page = virt_to_page(buf);
-        sg->offset = (unsigned long) buf & ~PAGE_MASK;
-        sg->length = buflen;
+        sg_init_one(qc->sg, buf, buflen);
 }
 
 /**
@@ -2687,7 +2663,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
  *      None.  (grabs host lock)
  */
 
-void ata_poll_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
+void ata_poll_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
 {
         struct ata_port *ap = qc->ap;
         unsigned long flags;
@@ -2695,7 +2671,7 @@ void ata_poll_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
         spin_lock_irqsave(&ap->host_set->lock, flags);
         ap->flags &= ~ATA_FLAG_NOINTR;
         ata_irq_on(ap);
-        ata_qc_complete(qc, drv_stat);
+        ata_qc_complete(qc, err_mask);
         spin_unlock_irqrestore(&ap->host_set->lock, flags);
 }
 
@@ -2792,7 +2768,7 @@ static int ata_pio_complete (struct ata_port *ap)
 
         ap->hsm_task_state = HSM_ST_IDLE;
 
-        ata_poll_qc_complete(qc, drv_stat);
+        ata_poll_qc_complete(qc, 0);
 
         /* another command may start at this point */
 
@@ -3160,18 +3136,15 @@ static void ata_pio_block(struct ata_port *ap)
 static void ata_pio_error(struct ata_port *ap)
 {
         struct ata_queued_cmd *qc;
-        u8 drv_stat;
+
+        printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
         assert(qc != NULL);
 
-        drv_stat = ata_chk_status(ap);
-        printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
-               ap->id, drv_stat);
-
         ap->hsm_task_state = HSM_ST_IDLE;
 
-        ata_poll_qc_complete(qc, drv_stat | ATA_ERR);
+        ata_poll_qc_complete(qc, AC_ERR_ATA_BUS);
 }
 
 static void ata_pio_task(void *_data)
@@ -3294,7 +3267,7 @@ static void ata_qc_timeout(struct ata_queued_cmd *qc)
                        ap->id, qc->tf.command, drv_stat, host_stat);
 
                 /* complete taskfile transaction */
-                ata_qc_complete(qc, drv_stat);
+                ata_qc_complete(qc, ac_err_mask(drv_stat));
                 break;
         }
 
@@ -3399,7 +3372,7 @@ struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
         return qc;
 }
 
-int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
+int ata_qc_complete_noop(struct ata_queued_cmd *qc, unsigned int err_mask)
 {
         return 0;
 }
@@ -3458,7 +3431,7 @@ void ata_qc_free(struct ata_queued_cmd *qc)
  *      spin_lock_irqsave(host_set lock)
  */
 
-void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
+void ata_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
 {
         int rc;
 
@@ -3475,7 +3448,7 @@ void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
         qc->flags &= ~ATA_QCFLAG_ACTIVE;
 
         /* call completion callback */
-        rc = qc->complete_fn(qc, drv_stat);
+        rc = qc->complete_fn(qc, err_mask);
 
         /* if callback indicates not to complete command (non-zero),
          * return immediately
@@ -3913,7 +3886,7 @@ inline unsigned int ata_host_intr (struct ata_port *ap,
                 ap->ops->irq_clear(ap);
 
                 /* complete taskfile transaction */
-                ata_qc_complete(qc, status);
+                ata_qc_complete(qc, ac_err_mask(status));
                 break;
 
         default:
@@ -4008,7 +3981,7 @@ static void atapi_packet_task(void *_data)
         /* sleep-wait for BSY to clear */
         DPRINTK("busy wait\n");
         if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
-                goto err_out;
+                goto err_out_status;
 
         /* make sure DRQ is set */
         status = ata_chk_status(ap);
@@ -4045,8 +4018,10 @@ static void atapi_packet_task(void *_data)
 
         return;
 
+err_out_status:
+        status = ata_chk_status(ap);
 err_out:
-        ata_poll_qc_complete(qc, ATA_ERR);
+        ata_poll_qc_complete(qc, __ac_err_mask(status));
 }
 
 
@@ -4254,11 +4229,10 @@ int ata_device_add(const struct ata_probe_ent *ent)
 
         DPRINTK("ENTER\n");
         /* alloc a container for our list of ATA ports (buses) */
-        host_set = kmalloc(sizeof(struct ata_host_set) +
+        host_set = kzalloc(sizeof(struct ata_host_set) +
                            (ent->n_ports * sizeof(void *)), GFP_KERNEL);
         if (!host_set)
                 return 0;
-        memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
         spin_lock_init(&host_set->lock);
 
         host_set->dev = dev;
@@ -4298,10 +4272,8 @@ int ata_device_add(const struct ata_probe_ent *ent)
                 count++;
         }
 
-        if (!count) {
-                kfree(host_set);
-                return 0;
-        }
+        if (!count)
+                goto err_free_ret;
 
         /* obtain irq, that is shared between channels */
         if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
@@ -4359,6 +4331,7 @@ err_out:
                 ata_host_remove(host_set->ports[i], 1);
                 scsi_host_put(host_set->ports[i]->host);
         }
+err_free_ret:
         kfree(host_set);
         VPRINTK("EXIT, returning 0\n");
         return 0;
@@ -4468,15 +4441,13 @@ ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
 {
         struct ata_probe_ent *probe_ent;
 
-        probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
+        probe_ent = kzalloc(sizeof(*probe_ent), GFP_KERNEL);
         if (!probe_ent) {
                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
                        kobject_name(&(dev->kobj)));
                 return NULL;
         }
 
-        memset(probe_ent, 0, sizeof(*probe_ent));
-
         INIT_LIST_HEAD(&probe_ent->node);
         probe_ent->dev = dev;
 
@@ -4556,11 +4527,11 @@ ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int
         return probe_ent;
 }
 
-static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, struct ata_port_info **port, int port_num)
+static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, struct ata_port_info *port, int port_num)
 {
         struct ata_probe_ent *probe_ent;
 
-        probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
+        probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port);
         if (!probe_ent)
                 return NULL;
 
@@ -4707,9 +4678,9 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 
         if (legacy_mode) {
                 if (legacy_mode & (1 << 0))
-                        probe_ent = ata_pci_init_legacy_port(pdev, port, 0);
+                        probe_ent = ata_pci_init_legacy_port(pdev, port[0], 0);
                 if (legacy_mode & (1 << 1))
-                        probe_ent2 = ata_pci_init_legacy_port(pdev, port, 1);
+                        probe_ent2 = ata_pci_init_legacy_port(pdev, port[1], 1);
         } else {
                 if (n_ports == 2)
                         probe_ent = ata_pci_init_native_mode(pdev, port, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
@@ -4873,7 +4844,6 @@ EXPORT_SYMBOL_GPL(ata_tf_to_fis);
 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
 EXPORT_SYMBOL_GPL(ata_check_status);
 EXPORT_SYMBOL_GPL(ata_altstatus);
-EXPORT_SYMBOL_GPL(ata_chk_err);
 EXPORT_SYMBOL_GPL(ata_exec_command);
 EXPORT_SYMBOL_GPL(ata_port_start);
 EXPORT_SYMBOL_GPL(ata_port_stop);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 58858886d751..1e3792f86fcf 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -40,14 +40,56 @@
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
+#include <linux/hdreg.h>
 #include <asm/uaccess.h>
 
 #include "libata.h"
 
+#define SECTOR_SIZE     512
+
 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, const u8 *scsicmd);
 static struct ata_device *
 ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev);
 
+#define RW_RECOVERY_MPAGE 0x1
+#define RW_RECOVERY_MPAGE_LEN 12
+#define CACHE_MPAGE 0x8
+#define CACHE_MPAGE_LEN 20
+#define CONTROL_MPAGE 0xa
+#define CONTROL_MPAGE_LEN 12
+#define ALL_MPAGES 0x3f
+#define ALL_SUB_MPAGES 0xff
+
+
+static const u8 def_rw_recovery_mpage[] = {
+        RW_RECOVERY_MPAGE,
+        RW_RECOVERY_MPAGE_LEN - 2,
+        (1 << 7) |      /* AWRE, sat-r06 say it shall be 0 */
+            (1 << 6),   /* ARRE (auto read reallocation) */
+        0,              /* read retry count */
+        0, 0, 0, 0,
+        0,              /* write retry count */
+        0, 0, 0
+};
+
+static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
+        CACHE_MPAGE,
+        CACHE_MPAGE_LEN - 2,
+        0,              /* contains WCE, needs to be 0 for logic */
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0,              /* contains DRA, needs to be 0 for logic */
+        0, 0, 0, 0, 0, 0, 0
+};
+
+static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
+        CONTROL_MPAGE,
+        CONTROL_MPAGE_LEN - 2,
+        2,      /* DSENSE=0, GLTSD=1 */
+        0,      /* [QAM+QERR may be 1, see 05-359r1] */
+        0, 0, 0, 0, 0xff, 0xff,
+        0, 30   /* extended self test time, see 05-359r1 */
+};
+
 
 static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
                                    void (*done)(struct scsi_cmnd *))
@@ -86,6 +128,150 @@ int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
         return 0;
 }
 
+/**
+ *      ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
+ *      @dev: Device to whom we are issuing command
+ *      @arg: User provided data for issuing command
+ *
+ *      LOCKING:
+ *      Defined by the SCSI layer.  We don't really care.
+ *
+ *      RETURNS:
+ *      Zero on success, negative errno on error.
+ */
+
+int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
+{
+        int rc = 0;
+        u8 scsi_cmd[MAX_COMMAND_SIZE];
+        u8 args[4], *argbuf = NULL;
+        int argsize = 0;
+        struct scsi_request *sreq;
+
+        if (NULL == (void *)arg)
+                return -EINVAL;
+
+        if (copy_from_user(args, arg, sizeof(args)))
+                return -EFAULT;
+
+        sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
+        if (!sreq)
+                return -EINTR;
+
+        memset(scsi_cmd, 0, sizeof(scsi_cmd));
+
+        if (args[3]) {
+                argsize = SECTOR_SIZE * args[3];
+                argbuf = kmalloc(argsize, GFP_KERNEL);
+                if (argbuf == NULL) {
+                        rc = -ENOMEM;
+                        goto error;
+                }
+
+                scsi_cmd[1]  = (4 << 1); /* PIO Data-in */
+                scsi_cmd[2]  = 0x0e;     /* no off.line or cc, read from dev,
+                                            block count in sector count field */
+                sreq->sr_data_direction = DMA_FROM_DEVICE;
+        } else {
+                scsi_cmd[1]  = (3 << 1); /* Non-data */
+                /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
+                sreq->sr_data_direction = DMA_NONE;
+        }
+
+        scsi_cmd[0] = ATA_16;
+
+        scsi_cmd[4] = args[2];
+        if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
+                scsi_cmd[6]  = args[3];
+                scsi_cmd[8]  = args[1];
+                scsi_cmd[10] = 0x4f;
+                scsi_cmd[12] = 0xc2;
+        } else {
+                scsi_cmd[6]  = args[1];
+        }
+        scsi_cmd[14] = args[0];
+
+        /* Good values for timeout and retries?  Values below
+           from scsi_ioctl_send_command() for default case... */
+        scsi_wait_req(sreq, scsi_cmd, argbuf, argsize, (10*HZ), 5);
+
+        if (sreq->sr_result) {
+                rc = -EIO;
+                goto error;
+        }
+
+        /* Need code to retrieve data from check condition? */
+
+        if ((argbuf)
+         && copy_to_user((void *)(arg + sizeof(args)), argbuf, argsize))
+                rc = -EFAULT;
+error:
+        scsi_release_request(sreq);
+
+        if (argbuf)
+                kfree(argbuf);
+
+        return rc;
+}
+
+/**
+ *      ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
+ *      @dev: Device to whom we are issuing command
+ *      @arg: User provided data for issuing command
+ *
+ *      LOCKING:
+ *      Defined by the SCSI layer.  We don't really care.
+ *
+ *      RETURNS:
+ *      Zero on success, negative errno on error.
+ */
+int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
+{
+        int rc = 0;
+        u8 scsi_cmd[MAX_COMMAND_SIZE];
+        u8 args[7];
+        struct scsi_request *sreq;
+
+        if (NULL == (void *)arg)
+                return -EINVAL;
+
+        if (copy_from_user(args, arg, sizeof(args)))
+                return -EFAULT;
+
+        memset(scsi_cmd, 0, sizeof(scsi_cmd));
+        scsi_cmd[0]  = ATA_16;
+        scsi_cmd[1]  = (3 << 1); /* Non-data */
+        /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
+        scsi_cmd[4]  = args[1];
+        scsi_cmd[6]  = args[2];
+        scsi_cmd[8]  = args[3];
+        scsi_cmd[10] = args[4];
+        scsi_cmd[12] = args[5];
+        scsi_cmd[14] = args[0];
+
+        sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
+        if (!sreq) {
+                rc = -EINTR;
+                goto error;
+        }
+
+        sreq->sr_data_direction = DMA_NONE;
+        /* Good values for timeout and retries?  Values below
+           from scsi_ioctl_send_command() for default case... */
+        scsi_wait_req(sreq, scsi_cmd, NULL, 0, (10*HZ), 5);
+
+        if (sreq->sr_result) {
+                rc = -EIO;
+                goto error;
+        }
+
+        /* Need code to retrieve data from check condition? */
+
+error:
+        scsi_release_request(sreq);
+        return rc;
+}
+
 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
 {
         struct ata_port *ap;
@@ -115,6 +301,16 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
                         return -EINVAL;
                 return 0;
 
+        case HDIO_DRIVE_CMD:
+                if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
+                        return -EACCES;
+                return ata_cmd_ioctl(scsidev, arg);
+
+        case HDIO_DRIVE_TASK:
+                if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
+                        return -EACCES;
+                return ata_task_ioctl(scsidev, arg);
+
         default:
                 rc = -ENOTTY;
                 break;
@@ -173,23 +369,70 @@ struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
 }
 
 /**
+ *      ata_dump_status - user friendly display of error info
+ *      @id: id of the port in question
+ *      @tf: ptr to filled out taskfile
+ *
+ *      Decode and dump the ATA error/status registers for the user so
+ *      that they have some idea what really happened at the non
+ *      make-believe layer.
+ *
+ *      LOCKING:
+ *      inherited from caller
+ */
+void ata_dump_status(unsigned id, struct ata_taskfile *tf)
+{
+        u8 stat = tf->command, err = tf->feature;
+
+        printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
+        if (stat & ATA_BUSY) {
+                printk("Busy }\n");     /* Data is not valid in this case */
+        } else {
+                if (stat & 0x40)        printk("DriveReady ");
+                if (stat & 0x20)        printk("DeviceFault ");
+                if (stat & 0x10)        printk("SeekComplete ");
+                if (stat & 0x08)        printk("DataRequest ");
+                if (stat & 0x04)        printk("CorrectedError ");
+                if (stat & 0x02)        printk("Index ");
+                if (stat & 0x01)        printk("Error ");
+                printk("}\n");
+
+                if (err) {
+                        printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
+                        if (err & 0x04)         printk("DriveStatusError ");
+                        if (err & 0x80) {
+                                if (err & 0x04) printk("BadCRC ");
+                                else            printk("Sector ");
+                        }
+                        if (err & 0x40)         printk("UncorrectableError ");
+                        if (err & 0x10)         printk("SectorIdNotFound ");
+                        if (err & 0x02)         printk("TrackZeroNotFound ");
+                        if (err & 0x01)         printk("AddrMarkNotFound ");
+                        printk("}\n");
+                }
+        }
+}
+
+/**
  *      ata_to_sense_error - convert ATA error to SCSI error
- *      @qc: Command that we are erroring out
  *      @drv_stat: value contained in ATA status register
+ *      @drv_err: value contained in ATA error register
+ *      @sk: the sense key we'll fill out
+ *      @asc: the additional sense code we'll fill out
+ *      @ascq: the additional sense code qualifier we'll fill out
  *
- *      Converts an ATA error into a SCSI error. While we are at it
- *      we decode and dump the ATA error for the user so that they
- *      have some idea what really happened at the non make-believe
- *      layer.
+ *      Converts an ATA error into a SCSI error.  Fill out pointers to
+ *      SK, ASC, and ASCQ bytes for later use in fixed or descriptor
+ *      format sense blocks.
  *
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
  */
-
-void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
+void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc, 
+                        u8 *ascq)
 {
-        struct scsi_cmnd *cmd = qc->scsicmd;
-        u8 err = 0;
+        int i;
+
         /* Based on the 3ware driver translation table */
         static unsigned char sense_table[][4] = {
                 /* BBD|ECC|ID|MAR */
@@ -230,96 +473,192 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
                 {0x04,          RECOVERED_ERROR, 0x11, 0x00},   // Recovered ECC error    Medium error, recovered
                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
         };
-        int i = 0;
 
         /*
          *      Is this an error we can process/parse
          */
+        if (drv_stat & ATA_BUSY) {
+                drv_err = 0;    /* Ignore the err bits, they're invalid */
+        }
 
-        if(drv_stat & ATA_ERR)
-                /* Read the err bits */
-                err = ata_chk_err(qc->ap);
+        if (drv_err) {
+                /* Look for drv_err */
+                for (i = 0; sense_table[i][0] != 0xFF; i++) {
+                        /* Look for best matches first */
+                        if ((sense_table[i][0] & drv_err) == 
+                            sense_table[i][0]) {
+                                *sk = sense_table[i][1];
+                                *asc = sense_table[i][2];
+                                *ascq = sense_table[i][3];
+                                goto translate_done;
+                        }
+                }
+                /* No immediate match */
+                printk(KERN_WARNING "ata%u: no sense translation for "
+                       "error 0x%02x\n", id, drv_err);
+        }
 
-        /* Display the ATA level error info */
+        /* Fall back to interpreting status bits */
+        for (i = 0; stat_table[i][0] != 0xFF; i++) {
+                if (stat_table[i][0] & drv_stat) {
+                        *sk = stat_table[i][1];
+                        *asc = stat_table[i][2];
+                        *ascq = stat_table[i][3];
+                        goto translate_done;
+                }
+        }
+        /* No error?  Undecoded? */
+        printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n", 
+               id, drv_stat);
 
-        printk(KERN_WARNING "ata%u: status=0x%02x { ", qc->ap->id, drv_stat);
-        if(drv_stat & 0x80)
-        {
-                printk("Busy ");
-                err = 0;        /* Data is not valid in this case */
+        /* For our last chance pick, use medium read error because
+         * it's much more common than an ATA drive telling you a write
+         * has failed.
+         */
+        *sk = MEDIUM_ERROR;
+        *asc = 0x11; /* "unrecovered read error" */
+        *ascq = 0x04; /*  "auto-reallocation failed" */
+
+ translate_done:
+        printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x to "
+               "SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n", id, drv_stat, drv_err,
+               *sk, *asc, *ascq);
+        return;
+}
+
+/*
+ *      ata_gen_ata_desc_sense - Generate check condition sense block.
+ *      @qc: Command that completed.
+ *
+ *      This function is specific to the ATA descriptor format sense
+ *      block specified for the ATA pass through commands.  Regardless
+ *      of whether the command errored or not, return a sense
+ *      block. Copy all controller registers into the sense
+ *      block. Clear sense key, ASC & ASCQ if there is no error.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
+void ata_gen_ata_desc_sense(struct ata_queued_cmd *qc)
+{
+        struct scsi_cmnd *cmd = qc->scsicmd;
+        struct ata_taskfile *tf = &qc->tf;
+        unsigned char *sb = cmd->sense_buffer;
+        unsigned char *desc = sb + 8;
+
+        memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
+
+        cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
+
+        /*
+         * Read the controller registers.
+         */
+        assert(NULL != qc->ap->ops->tf_read);
+        qc->ap->ops->tf_read(qc->ap, tf);
+
+        /*
+         * Use ata_to_sense_error() to map status register bits
+         * onto sense key, asc & ascq.
+         */
+        if (tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
+                ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
+                                   &sb[1], &sb[2], &sb[3]);
+                sb[1] &= 0x0f;
         }
-        else {
-                if(drv_stat & 0x40)     printk("DriveReady ");
-                if(drv_stat & 0x20)     printk("DeviceFault ");
-                if(drv_stat & 0x10)     printk("SeekComplete ");
-                if(drv_stat & 0x08)     printk("DataRequest ");
-                if(drv_stat & 0x04)     printk("CorrectedError ");
-                if(drv_stat & 0x02)     printk("Index ");
-                if(drv_stat & 0x01)     printk("Error ");
+
+        /*
+         * Sense data is current and format is descriptor.
+         */
+        sb[0] = 0x72;
+
+        desc[0] = 0x09;
+
+        /*
+         * Set length of additional sense data.
+         * Since we only populate descriptor 0, the total
+         * length is the same (fixed) length as descriptor 0.
+         */
+        desc[1] = sb[7] = 14;
+
+        /*
+         * Copy registers into sense buffer.
+         */
+        desc[2] = 0x00;
+        desc[3] = tf->feature;  /* == error reg */
+        desc[5] = tf->nsect;
+        desc[7] = tf->lbal;
+        desc[9] = tf->lbam;
+        desc[11] = tf->lbah;
+        desc[12] = tf->device;
+        desc[13] = tf->command; /* == status reg */
+
+        /*
+         * Fill in Extend bit, and the high order bytes
+         * if applicable.
+         */
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                desc[2] |= 0x01;
+                desc[4] = tf->hob_nsect;
+                desc[6] = tf->hob_lbal;
+                desc[8] = tf->hob_lbam;
+                desc[10] = tf->hob_lbah;
         }
-        printk("}\n");
-
-        if(err)
-        {
-                printk(KERN_WARNING "ata%u: error=0x%02x { ", qc->ap->id, err);
-                if(err & 0x04)          printk("DriveStatusError ");
-                if(err & 0x80)
-                {
-                        if(err & 0x04)
-                                printk("BadCRC ");
-                        else
-                                printk("Sector ");
-                }
-                if(err & 0x40)          printk("UncorrectableError ");
-                if(err & 0x10)          printk("SectorIdNotFound ");
-                if(err & 0x02)          printk("TrackZeroNotFound ");
-                if(err & 0x01)          printk("AddrMarkNotFound ");
-                printk("}\n");
+}
 
-                /* Should we dump sector info here too ?? */
+/**
+ *      ata_gen_fixed_sense - generate a SCSI fixed sense block
+ *      @qc: Command that we are erroring out
+ *
+ *      Leverage ata_to_sense_error() to give us the codes.  Fit our
+ *      LBA in here if there's room.
+ *
+ *      LOCKING:
+ *      inherited from caller
+ */
+void ata_gen_fixed_sense(struct ata_queued_cmd *qc)
+{
+        struct scsi_cmnd *cmd = qc->scsicmd;
+        struct ata_taskfile *tf = &qc->tf;
+        unsigned char *sb = cmd->sense_buffer;
+
+        memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
+
+        cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
+
+        /*
+         * Read the controller registers.
+         */
+        assert(NULL != qc->ap->ops->tf_read);
+        qc->ap->ops->tf_read(qc->ap, tf);
+
+        /*
+         * Use ata_to_sense_error() to map status register bits
+         * onto sense key, asc & ascq.
+         */
+        if (tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
+                ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
+                                   &sb[2], &sb[12], &sb[13]);
+                sb[2] &= 0x0f;
         }
 
+        sb[0] = 0x70;
+        sb[7] = 0x0a;
 
-        /* Look for err */
-        while(sense_table[i][0] != 0xFF)
-        {
-                /* Look for best matches first */
-                if((sense_table[i][0] & err) == sense_table[i][0])
-                {
-                        ata_scsi_set_sense(cmd, sense_table[i][1] /* sk */,
-                                           sense_table[i][2] /* asc */,
-                                           sense_table[i][3] /* ascq */ );
-                        return;
-                }
-                i++;
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                /* TODO: find solution for LBA48 descriptors */
         }
-        /* No immediate match */
-        if(err)
-                printk(KERN_DEBUG "ata%u: no sense translation for 0x%02x\n", qc->ap->id, err);
 
-        i = 0;
-        /* Fall back to interpreting status bits */
-        while(stat_table[i][0] != 0xFF)
-        {
-                if(stat_table[i][0] & drv_stat)
-                {
-                        ata_scsi_set_sense(cmd, sense_table[i][1] /* sk */,
-                                           sense_table[i][2] /* asc */,
-                                           sense_table[i][3] /* ascq */ );
-                        return;
-                }
-                i++;
+        else if (tf->flags & ATA_TFLAG_LBA) {
+                /* A small (28b) LBA will fit in the 32b info field */
+                sb[0] |= 0x80;          /* set valid bit */
+                sb[3] = tf->device & 0x0f;
+                sb[4] = tf->lbah;
+                sb[5] = tf->lbam;
+                sb[6] = tf->lbal;
         }
-        /* No error ?? */
-        printk(KERN_ERR "ata%u: called with no error (%02X)!\n", qc->ap->id, drv_stat);
-        /* additional-sense-code[-qualifier] */
 
-        if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
-                ata_scsi_set_sense(cmd, MEDIUM_ERROR, 0x11, 0x4);
-                /* "unrecovered read error" */
-        } else {
-                ata_scsi_set_sense(cmd, MEDIUM_ERROR, 0xc, 0x2);
-                /* "write error - auto-reallocation failed" */
+        else {
+                /* TODO: C/H/S */
         }
 }
 
@@ -868,14 +1207,41 @@ nothing_to_do:
         return 1;
 }
 
-static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
+static int ata_scsi_qc_complete(struct ata_queued_cmd *qc,
+                                unsigned int err_mask)
 {
         struct scsi_cmnd *cmd = qc->scsicmd;
+        u8 *cdb = cmd->cmnd;
+        int need_sense = (err_mask != 0);
+
+        /* For ATA pass thru (SAT) commands, generate a sense block if
+         * user mandated it or if there's an error.  Note that if we
+         * generate because the user forced us to, a check condition
+         * is generated and the ATA register values are returned
+         * whether the command completed successfully or not. If there
+         * was no error, SK, ASC and ASCQ will all be zero.
+         */
+        if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
+            ((cdb[2] & 0x20) || need_sense)) {
+                ata_gen_ata_desc_sense(qc);
+        } else {
+                if (!need_sense) {
+                        cmd->result = SAM_STAT_GOOD;
+                } else {
+                        /* TODO: decide which descriptor format to use
+                         * for 48b LBA devices and call that here
+                         * instead of the fixed desc, which is only
+                         * good for smaller LBA (and maybe CHS?)
+                         * devices.
+                         */
+                        ata_gen_fixed_sense(qc);
+                }
+        }
 
-        if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
-                ata_to_sense_error(qc, drv_stat);
-        else
-                cmd->result = SAM_STAT_GOOD;
+        if (need_sense) {
+                /* The ata_gen_..._sense routines fill in tf */
+                ata_dump_status(qc->ap->id, &qc->tf);
+        }
 
         qc->scsidone(cmd);
 
@@ -1266,13 +1632,9 @@ static void ata_msense_push(u8 **ptr_io, const u8 *last,
 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
                                        const u8 *last)
 {
-        u8 page[] = {
-                0x8,                            /* page code */
-                0x12,                           /* page length */
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 10 zeroes */
-                0, 0, 0, 0, 0, 0, 0, 0          /* 8 zeroes */
-        };
+        u8 page[CACHE_MPAGE_LEN];
 
+        memcpy(page, def_cache_mpage, sizeof(page));
         if (ata_id_wcache_enabled(id))
                 page[2] |= (1 << 2);    /* write cache enable */
         if (!ata_id_rahead_enabled(id))
@@ -1296,15 +1658,9 @@ static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
 
 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
 {
-        const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
-
-        /* byte 2: set the descriptor format sense data bit (bit 2)
-         * since we need to support returning this format for SAT
-         * commands and any SCSI commands against a 48b LBA device.
-         */
-
-        ata_msense_push(ptr_io, last, page, sizeof(page));
-        return sizeof(page);
+        ata_msense_push(ptr_io, last, def_control_mpage,
+                        sizeof(def_control_mpage));
+        return sizeof(def_control_mpage);
 }
 
 /**
@@ -1321,15 +1677,10 @@ static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
 
 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
 {
-        const u8 page[] = {
-                0x1,                      /* page code */
-                0xa,                      /* page length */
-                (1 << 7) | (1 << 6),      /* note auto r/w reallocation */
-                0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
-        };
 
-        ata_msense_push(ptr_io, last, page, sizeof(page));
-        return sizeof(page);
+        ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
+                        sizeof(def_rw_recovery_mpage));
+        return sizeof(def_rw_recovery_mpage);
 }
 
 /**
@@ -1338,7 +1689,9 @@ static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
  *      @buflen: Response buffer length.
  *
- *      Simulate MODE SENSE commands.
+ *      Simulate MODE SENSE commands. Assume this is invoked for direct
+ *      access devices (e.g. disks) only. There should be no block
+ *      descriptor for other device types.
  *
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
@@ -1348,15 +1701,22 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                                   unsigned int buflen)
 {
         u8 *scsicmd = args->cmd->cmnd, *p, *last;
-        unsigned int page_control, six_byte, output_len;
+        const u8 sat_blk_desc[] = {
+                0, 0, 0, 0,     /* number of blocks: sat unspecified */
+                0,
+                0, 0x2, 0x0     /* block length: 512 bytes */
+        };
+        u8 pg, spg;
+        unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
 
         VPRINTK("ENTER\n");
 
         six_byte = (scsicmd[0] == MODE_SENSE);
-
-        /* we only support saved and current values (which we treat
-         * in the same manner)
+        ebd = !(scsicmd[1] & 0x8);      /* dbd bit inverted == edb */
+        /*
+         * LLBA bit in msense(10) ignored (compliant)
          */
+
         page_control = scsicmd[2] >> 6;
         switch (page_control) {
         case 0: /* current */
@@ -1369,29 +1729,42 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                 goto invalid_fld;
         }
 
-        if (six_byte)
-                output_len = 4;
-        else
-                output_len = 8;
+        if (six_byte) {
+                output_len = 4 + (ebd ? 8 : 0);
+                alloc_len = scsicmd[4];
+        } else {
+                output_len = 8 + (ebd ? 8 : 0);
+                alloc_len = (scsicmd[7] << 8) + scsicmd[8];
+        }
+        minlen = (alloc_len < buflen) ? alloc_len : buflen;
 
         p = rbuf + output_len;
-        last = rbuf + buflen - 1;
+        last = rbuf + minlen - 1;
 
-        switch(scsicmd[2] & 0x3f) {
-        case 0x01:              /* r/w error recovery */
+        pg = scsicmd[2] & 0x3f;
+        spg = scsicmd[3];
+        /*
+         * No mode subpages supported (yet) but asking for _all_
+         * subpages may be valid
+         */
+        if (spg && (spg != ALL_SUB_MPAGES))
+                goto invalid_fld;
+
+        switch(pg) {
+        case RW_RECOVERY_MPAGE:
                 output_len += ata_msense_rw_recovery(&p, last);
                 break;
 
-        case 0x08:              /* caching */
+        case CACHE_MPAGE:
                 output_len += ata_msense_caching(args->id, &p, last);
                 break;
 
-        case 0x0a: {            /* control mode */
+        case CONTROL_MPAGE: {
                 output_len += ata_msense_ctl_mode(&p, last);
                 break;
                 }
 
-        case 0x3f:              /* all pages */
+        case ALL_MPAGES:
                 output_len += ata_msense_rw_recovery(&p, last);
                 output_len += ata_msense_caching(args->id, &p, last);
                 output_len += ata_msense_ctl_mode(&p, last);
@@ -1401,15 +1774,31 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                 goto invalid_fld;
         }
 
+        if (minlen < 1)
+                return 0;
         if (six_byte) {
                 output_len--;
                 rbuf[0] = output_len;
+                if (ebd) {
+                        if (minlen > 3)
+                                rbuf[3] = sizeof(sat_blk_desc);
+                        if (minlen > 11)
+                                memcpy(rbuf + 4, sat_blk_desc,
+                                       sizeof(sat_blk_desc));
+                }
         } else {
                 output_len -= 2;
                 rbuf[0] = output_len >> 8;
-                rbuf[1] = output_len;
+                if (minlen > 1)
+                        rbuf[1] = output_len;
+                if (ebd) {
+                        if (minlen > 7)
+                                rbuf[7] = sizeof(sat_blk_desc);
+                        if (minlen > 15)
+                                memcpy(rbuf + 8, sat_blk_desc,
+                                       sizeof(sat_blk_desc));
+                }
         }
-
         return 0;
 
 invalid_fld:
@@ -1616,16 +2005,13 @@ void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
         DPRINTK("EXIT\n");
 }
 
-static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
+static int atapi_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
 {
         struct scsi_cmnd *cmd = qc->scsicmd;
 
-        VPRINTK("ENTER, drv_stat == 0x%x\n", drv_stat);
-
-        if (unlikely(drv_stat & (ATA_BUSY | ATA_DRQ)))
-                ata_to_sense_error(qc, drv_stat);
+        VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
 
-        else if (unlikely(drv_stat & ATA_ERR)) {
+        if (unlikely(err_mask & AC_ERR_DEV)) {
                 DPRINTK("request check condition\n");
 
                 /* FIXME: command completion with check condition
@@ -1642,6 +2028,14 @@ static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
                 return 1;
         }
 
+        else if (unlikely(err_mask))
+                /* FIXME: not quite right; we don't want the
+                 * translation of taskfile registers into
+                 * a sense descriptors, since that's only
+                 * correct for ATA, not ATAPI
+                 */
+                ata_gen_ata_desc_sense(qc);
+
         else {
                 u8 *scsicmd = cmd->cmnd;
 
@@ -1782,6 +2176,143 @@ ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
         return dev;
 }
 
+/*
+ *      ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
+ *      @byte1: Byte 1 from pass-thru CDB.
+ *
+ *      RETURNS:
+ *      ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
+ */
+static u8
+ata_scsi_map_proto(u8 byte1)
+{
+        switch((byte1 & 0x1e) >> 1) {
+                case 3:         /* Non-data */
+                        return ATA_PROT_NODATA;
+
+                case 6:         /* DMA */
+                        return ATA_PROT_DMA;
+
+                case 4:         /* PIO Data-in */
+                case 5:         /* PIO Data-out */
+                        if (byte1 & 0xe0) {
+                                return ATA_PROT_PIO_MULT;
+                        }
+                        return ATA_PROT_PIO;
+
+                case 10:        /* Device Reset */
+                case 0:         /* Hard Reset */
+                case 1:         /* SRST */
+                case 2:         /* Bus Idle */
+                case 7:         /* Packet */
+                case 8:         /* DMA Queued */
+                case 9:         /* Device Diagnostic */
+                case 11:        /* UDMA Data-in */
+                case 12:        /* UDMA Data-Out */
+                case 13:        /* FPDMA */
+                default:        /* Reserved */
+                        break;
+        }
+
+        return ATA_PROT_UNKNOWN;
+}
+
+/**
+ *      ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
+ *      @qc: command structure to be initialized
+ *      @cmd: SCSI command to convert
+ *
+ *      Handles either 12 or 16-byte versions of the CDB.
+ *
+ *      RETURNS:
+ *      Zero on success, non-zero on failure.
+ */
+static unsigned int
+ata_scsi_pass_thru(struct ata_queued_cmd *qc, const u8 *scsicmd)
+{
+        struct ata_taskfile *tf = &(qc->tf);
+        struct scsi_cmnd *cmd = qc->scsicmd;
+
+        if ((tf->protocol = ata_scsi_map_proto(scsicmd[1])) == ATA_PROT_UNKNOWN)
+                return 1;
+
+        /*
+         * 12 and 16 byte CDBs use different offsets to
+         * provide the various register values.
+         */
+        if (scsicmd[0] == ATA_16) {
+                /*
+                 * 16-byte CDB - may contain extended commands.
+                 *
+                 * If that is the case, copy the upper byte register values.
+                 */
+                if (scsicmd[1] & 0x01) {
+                        tf->hob_feature = scsicmd[3];
+                        tf->hob_nsect = scsicmd[5];
+                        tf->hob_lbal = scsicmd[7];
+                        tf->hob_lbam = scsicmd[9];
+                        tf->hob_lbah = scsicmd[11];
+                        tf->flags |= ATA_TFLAG_LBA48;
+                } else
+                        tf->flags &= ~ATA_TFLAG_LBA48;
+
+                /*
+                 * Always copy low byte, device and command registers.
+                 */
+                tf->feature = scsicmd[4];
+                tf->nsect = scsicmd[6];
+                tf->lbal = scsicmd[8];
+                tf->lbam = scsicmd[10];
+                tf->lbah = scsicmd[12];
+                tf->device = scsicmd[13];
+                tf->command = scsicmd[14];
+        } else {
+                /*
+                 * 12-byte CDB - incapable of extended commands.
+                 */
+                tf->flags &= ~ATA_TFLAG_LBA48;
+
+                tf->feature = scsicmd[3];
+                tf->nsect = scsicmd[4];
+                tf->lbal = scsicmd[5];
+                tf->lbam = scsicmd[6];
+                tf->lbah = scsicmd[7];
+                tf->device = scsicmd[8];
+                tf->command = scsicmd[9];
+        }
+
+        /*
+         * Filter SET_FEATURES - XFER MODE command -- otherwise,
+         * SET_FEATURES - XFER MODE must be preceded/succeeded
+         * by an update to hardware-specific registers for each
+         * controller (i.e. the reason for ->set_piomode(),
+         * ->set_dmamode(), and ->post_set_mode() hooks).
+         */
+        if ((tf->command == ATA_CMD_SET_FEATURES)
+         && (tf->feature == SETFEATURES_XFER))
+                return 1;
+
+        /*
+         * Set flags so that all registers will be written,
+         * and pass on write indication (used for PIO/DMA
+         * setup.)
+         */
+        tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
+
+        if (cmd->sc_data_direction == DMA_TO_DEVICE)
+                tf->flags |= ATA_TFLAG_WRITE;
+
+        /*
+         * Set transfer length.
+         *
+         * TODO: find out if we need to do more here to
+         *       cover scatter/gather case.
+         */
+        qc->nsect = cmd->bufflen / ATA_SECT_SIZE;
+
+        return 0;
+}
+
 /**
  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
  *      @dev: ATA device
@@ -1814,6 +2345,11 @@ static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
         case VERIFY:
         case VERIFY_16:
                 return ata_scsi_verify_xlat;
+
+        case ATA_12:
+        case ATA_16:
+                return ata_scsi_pass_thru;
+
         case START_STOP:
                 return ata_scsi_start_stop_xlat;
         }
@@ -1972,7 +2508,7 @@ void ata_scsi_simulate(u16 *id,
                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
                         break;
 
-                /* mandantory commands we haven't implemented yet */
+                /* mandatory commands we haven't implemented yet */
                 case REQUEST_SENSE:
 
                 /* all other commands */
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index 3d60190584ba..10ecd9e15e4f 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -39,7 +39,7 @@ struct ata_scsi_args {
 
 /* libata-core.c */
 extern int atapi_enabled;
-extern int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
+extern int ata_qc_complete_noop(struct ata_queued_cmd *qc, unsigned int err_mask);
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
                                       struct ata_device *dev);
 extern void ata_rwcmd_protocol(struct ata_queued_cmd *qc);
@@ -50,13 +50,14 @@ extern void ata_dev_select(struct ata_port *ap, unsigned int device,
                            unsigned int wait, unsigned int can_sleep);
 extern void ata_tf_to_host_nolock(struct ata_port *ap, const struct ata_taskfile *tf);
 extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
+extern int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg);
+extern int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg);
 
 
 /* libata-scsi.c */
 extern void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
                          struct scsi_cmnd *cmd);
 extern void ata_scsi_scan_host(struct ata_port *ap);
-extern void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat);
 extern int ata_scsi_error(struct Scsi_Host *host);
 extern unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
                                unsigned int buflen);
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index b235556b7b65..bdccf73cf9fe 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -730,7 +730,7 @@ static void start_phase(struct mesh_state *ms)
                  * issue a SEQ_MSGOUT to get the mesh to drop ACK.
                  */
                 if ((in_8(&mr->bus_status0) & BS0_ATN) == 0) {
-                        dlog(ms, "bus0 was %.2x explictly asserting ATN", mr->bus_status0);
+                        dlog(ms, "bus0 was %.2x explicitly asserting ATN", mr->bus_status0);
                         out_8(&mr->bus_status0, BS0_ATN); /* explicit ATN */
                         mesh_flush_io(mr);
                         udelay(1);
diff --git a/drivers/scsi/pdc_adma.c b/drivers/scsi/pdc_adma.c
index 9820f272f889..665017eda8a6 100644
--- a/drivers/scsi/pdc_adma.c
+++ b/drivers/scsi/pdc_adma.c
@@ -40,13 +40,14 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <asm/io.h>
 #include <linux/libata.h>
 
 #define DRV_NAME        "pdc_adma"
-#define DRV_VERSION     "0.01"
+#define DRV_VERSION     "0.03"
 
 /* macro to calculate base address for ATA regs */
 #define ADMA_ATA_REGS(base,port_no)     ((base) + ((port_no) * 0x40))
@@ -79,7 +80,6 @@ enum {
         aNIEN                   = (1 << 8), /* irq mask: 1==masked */
         aGO                     = (1 << 7), /* packet trigger ("Go!") */
         aRSTADM                 = (1 << 5), /* ADMA logic reset */
-        aRSTA                   = (1 << 2), /* ATA hard reset */
         aPIOMD4                 = 0x0003,   /* PIO mode 4 */
 
         /* ADMA_STATUS register bits */
@@ -452,24 +452,28 @@ static inline unsigned int adma_intr_pkt(struct ata_host_set *host_set)
                 struct adma_port_priv *pp;
                 struct ata_queued_cmd *qc;
                 void __iomem *chan = ADMA_REGS(mmio_base, port_no);
-                u8 drv_stat, status = readb(chan + ADMA_STATUS);
+                u8 status = readb(chan + ADMA_STATUS);
 
                 if (status == 0)
                         continue;
                 handled = 1;
                 adma_enter_reg_mode(ap);
-                if ((ap->flags & ATA_FLAG_PORT_DISABLED))
+                if (ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))
                         continue;
                 pp = ap->private_data;
                 if (!pp || pp->state != adma_state_pkt)
                         continue;
                 qc = ata_qc_from_tag(ap, ap->active_tag);
-                drv_stat = 0;
-                if ((status & (aPERR | aPSD | aUIRQ)))
-                        drv_stat = ATA_ERR;
-                else if (pp->pkt[0] != cDONE)
-                        drv_stat = ATA_ERR;
-                ata_qc_complete(qc, drv_stat);
+                if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
+                        unsigned int err_mask = 0;
+
+                        if ((status & (aPERR | aPSD | aUIRQ)))
+                                err_mask = AC_ERR_OTHER;
+                        else if (pp->pkt[0] != cDONE)
+                                err_mask = AC_ERR_OTHER;
+
+                        ata_qc_complete(qc, err_mask);
+                }
         }
         return handled;
 }
@@ -490,7 +494,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host_set *host_set)
                         if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
 
                                 /* check main status, clearing INTRQ */
-                                u8 status = ata_chk_status(ap);
+                                u8 status = ata_check_status(ap);
                                 if ((status & ATA_BUSY))
                                         continue;
                                 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
@@ -498,7 +502,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host_set *host_set)
                 
                                 /* complete taskfile transaction */
                                 pp->state = adma_state_idle;
-                                ata_qc_complete(qc, status);
+                                ata_qc_complete(qc, ac_err_mask(status));
                                 handled = 1;
                         }
                 }
@@ -561,15 +565,15 @@ static int adma_port_start(struct ata_port *ap)
         if ((pp->pkt_dma & 7) != 0) {
                 printk("bad alignment for pp->pkt_dma: %08x\n",
                                                 (u32)pp->pkt_dma);
-                goto err_out_kfree2;
+                dma_free_coherent(dev, ADMA_PKT_BYTES,
+                                                pp->pkt, pp->pkt_dma);
+                goto err_out_kfree;
         }
         memset(pp->pkt, 0, ADMA_PKT_BYTES);
         ap->private_data = pp;
         adma_reinit_engine(ap);
         return 0;
 
-err_out_kfree2:
-        kfree(pp);
 err_out_kfree:
         kfree(pp);
 err_out:
@@ -623,16 +627,14 @@ static int adma_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
 
         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME
-                        "(%s): 32-bit DMA enable failed\n",
-                        pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                        "32-bit DMA enable failed\n");
                 return rc;
         }
         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME
-                        "(%s): 32-bit consistent DMA enable failed\n",
-                        pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                        "32-bit consistent DMA enable failed\n");
                 return rc;
         }
         return 0;
@@ -648,7 +650,7 @@ static int adma_ata_init_one(struct pci_dev *pdev,
         int rc, port_no;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index 422e0b6f603a..46dbdee79f77 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -29,6 +29,7 @@
 #include <linux/interrupt.h>
 #include <linux/sched.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -258,7 +259,6 @@ struct mv_host_priv {
 static void mv_irq_clear(struct ata_port *ap);
 static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in);
 static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
-static u8 mv_check_err(struct ata_port *ap);
 static void mv_phy_reset(struct ata_port *ap);
 static void mv_host_stop(struct ata_host_set *host_set);
 static int mv_port_start(struct ata_port *ap);
@@ -296,7 +296,6 @@ static const struct ata_port_operations mv_ops = {
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
-        .check_err              = mv_check_err,
         .exec_command           = ata_exec_command,
         .dev_select             = ata_std_dev_select,
 
@@ -1067,6 +1066,7 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
         struct ata_queued_cmd *qc;
         u32 hc_irq_cause;
         int shift, port, port0, hard_port, handled;
+        unsigned int err_mask;
         u8 ata_status = 0;
 
         if (hc == 0) {
@@ -1102,15 +1102,15 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
                         handled++;
                 }
 
+                err_mask = ac_err_mask(ata_status);
+
                 shift = port << 1;              /* (port * 2) */
                 if (port >= MV_PORTS_PER_HC) {
                         shift++;        /* skip bit 8 in the HC Main IRQ reg */
                 }
                 if ((PORT0_ERR << shift) & relevant) {
                         mv_err_intr(ap);
-                        /* OR in ATA_ERR to ensure libata knows we took one */
-                        ata_status = readb((void __iomem *)
-                                           ap->ioaddr.status_addr) | ATA_ERR;
+                        err_mask |= AC_ERR_OTHER;
                         handled++;
                 }
                 
@@ -1120,7 +1120,7 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
                                 VPRINTK("port %u IRQ found for qc, "
                                         "ata_status 0x%x\n", port,ata_status);
                                 /* mark qc status appropriately */
-                                ata_qc_complete(qc, ata_status);
+                                ata_qc_complete(qc, err_mask);
                         }
                 }
         }
@@ -1185,22 +1185,6 @@ static irqreturn_t mv_interrupt(int irq, void *dev_instance,
 }
 
 /**
- *      mv_check_err - Return the error shadow register to caller.
- *      @ap: ATA channel to manipulate
- *
- *      Marvell requires DMA to be stopped before accessing shadow
- *      registers.  So we do that, then return the needed register.
- *
- *      LOCKING:
- *      Inherited from caller.  FIXME: protect mv_stop_dma with lock?
- */
-static u8 mv_check_err(struct ata_port *ap)
-{
-        mv_stop_dma(ap);                /* can't read shadow regs if DMA on */
-        return readb((void __iomem *) ap->ioaddr.error_addr);
-}
-
-/**
  *      mv_phy_reset - Perform eDMA reset followed by COMRESET
  *      @ap: ATA channel to manipulate
  *
@@ -1312,7 +1296,7 @@ static void mv_eng_timeout(struct ata_port *ap)
                  */
                 spin_lock_irqsave(&ap->host_set->lock, flags);
                 qc->scsidone = scsi_finish_command;
-                ata_qc_complete(qc, ATA_ERR);
+                ata_qc_complete(qc, AC_ERR_OTHER);
                 spin_unlock_irqrestore(&ap->host_set->lock, flags);
         }
 }
@@ -1454,9 +1438,9 @@ static void mv_print_info(struct ata_probe_ent *probe_ent)
         else
                 scc_s = "unknown";
 
-        printk(KERN_INFO DRV_NAME 
-               "(%s) %u slots %u ports %s mode IRQ via %s\n",
-               pci_name(pdev), (unsigned)MV_MAX_Q_DEPTH, probe_ent->n_ports, 
+        dev_printk(KERN_INFO, &pdev->dev,
+               "%u slots %u ports %s mode IRQ via %s\n",
+               (unsigned)MV_MAX_Q_DEPTH, probe_ent->n_ports, 
                scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
 }
 
@@ -1477,9 +1461,8 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         void __iomem *mmio_base;
         int pci_dev_busy = 0, rc;
 
-        if (!printed_version++) {
-                printk(KERN_INFO DRV_NAME " version " DRV_VERSION "\n");
-        }
+        if (!printed_version++)
+                dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc) {
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index 1a56d6c79ddd..d573888eda76 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -61,6 +61,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -383,7 +384,7 @@ static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                         return -ENODEV;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index eee93b0016df..b41c977d6fab 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -38,6 +38,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -195,6 +196,8 @@ static struct ata_port_info pdc_port_info[] = {
 static struct pci_device_id pdc_ata_pci_tbl[] = {
         { PCI_VENDOR_ID_PROMISE, 0x3371, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_2037x },
+        { PCI_VENDOR_ID_PROMISE, 0x3570, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_2037x },
         { PCI_VENDOR_ID_PROMISE, 0x3571, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_2037x },
         { PCI_VENDOR_ID_PROMISE, 0x3373, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
@@ -207,6 +210,8 @@ static struct pci_device_id pdc_ata_pci_tbl[] = {
           board_2037x },
         { PCI_VENDOR_ID_PROMISE, 0x3d75, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_2037x },
+        { PCI_VENDOR_ID_PROMISE, 0x3d73, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          board_2037x },
 
         { PCI_VENDOR_ID_PROMISE, 0x3318, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
           board_20319 },
@@ -395,7 +400,8 @@ static void pdc_eng_timeout(struct ata_port *ap)
         case ATA_PROT_DMA:
         case ATA_PROT_NODATA:
                 printk(KERN_ERR "ata%u: command timeout\n", ap->id);
-                ata_qc_complete(qc, ata_wait_idle(ap) | ATA_ERR);
+                drv_stat = ata_wait_idle(ap);
+                ata_qc_complete(qc, __ac_err_mask(drv_stat));
                 break;
 
         default:
@@ -404,7 +410,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
                 printk(KERN_ERR "ata%u: unknown timeout, cmd 0x%x stat 0x%x\n",
                        ap->id, qc->tf.command, drv_stat);
 
-                ata_qc_complete(qc, drv_stat);
+                ata_qc_complete(qc, ac_err_mask(drv_stat));
                 break;
         }
 
@@ -416,24 +422,21 @@ out:
 static inline unsigned int pdc_host_intr( struct ata_port *ap,
                                           struct ata_queued_cmd *qc)
 {
-        u8 status;
-        unsigned int handled = 0, have_err = 0;
+        unsigned int handled = 0, err_mask = 0;
         u32 tmp;
         void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL;
 
         tmp = readl(mmio);
         if (tmp & PDC_ERR_MASK) {
-                have_err = 1;
+                err_mask = AC_ERR_DEV;
                 pdc_reset_port(ap);
         }
 
         switch (qc->tf.protocol) {
         case ATA_PROT_DMA:
         case ATA_PROT_NODATA:
-                status = ata_wait_idle(ap);
-                if (have_err)
-                        status |= ATA_ERR;
-                ata_qc_complete(qc, status);
+                err_mask |= ac_err_mask(ata_wait_idle(ap));
+                ata_qc_complete(qc, err_mask);
                 handled = 1;
                 break;
 
@@ -631,7 +634,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         int rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index 250dafa6bc36..9938dae782b6 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <asm/io.h>
@@ -400,11 +401,12 @@ static inline unsigned int qs_intr_pkt(struct ata_host_set *host_set)
                                 qc = ata_qc_from_tag(ap, ap->active_tag);
                                 if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
                                         switch (sHST) {
-                                        case 0: /* sucessful CPB */
+                                        case 0: /* successful CPB */
                                         case 3: /* device error */
                                                 pp->state = qs_state_idle;
                                                 qs_enter_reg_mode(qc->ap);
-                                                ata_qc_complete(qc, sDST);
+                                                ata_qc_complete(qc,
+                                                        ac_err_mask(sDST));
                                                 break;
                                         default:
                                                 break;
@@ -433,7 +435,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host_set *host_set)
                         if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
 
                                 /* check main status, clearing INTRQ */
-                                u8 status = ata_chk_status(ap);
+                                u8 status = ata_check_status(ap);
                                 if ((status & ATA_BUSY))
                                         continue;
                                 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
@@ -441,7 +443,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host_set *host_set)
 
                                 /* complete taskfile transaction */
                                 pp->state = qs_state_idle;
-                                ata_qc_complete(qc, status);
+                                ata_qc_complete(qc, ac_err_mask(status));
                                 handled = 1;
                         }
                 }
@@ -599,25 +601,22 @@ static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
                 if (rc) {
                         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                         if (rc) {
-                                printk(KERN_ERR DRV_NAME
-                                        "(%s): 64-bit DMA enable failed\n",
-                                        pci_name(pdev));
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "64-bit DMA enable failed\n");
                                 return rc;
                         }
                 }
         } else {
                 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME
-                                "(%s): 32-bit DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "32-bit DMA enable failed\n");
                         return rc;
                 }
                 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
                 if (rc) {
-                        printk(KERN_ERR DRV_NAME
-                                "(%s): 32-bit consistent DMA enable failed\n",
-                                pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "32-bit consistent DMA enable failed\n");
                         return rc;
                 }
         }
@@ -634,7 +633,7 @@ static int qs_ata_init_one(struct pci_dev *pdev,
         int rc, port_no;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index 3a056173fb95..435f7e0085ec 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -41,6 +41,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -386,7 +387,7 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 cls;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
@@ -463,8 +464,8 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                         writeb(cls, mmio_base + SIL_FIFO_W3);
                 }
         } else
-                printk(KERN_WARNING DRV_NAME "(%s): cache line size not set.  Driver may not function\n",
-                        pci_name(pdev));
+                dev_printk(KERN_WARNING, &pdev->dev,
+                         "cache line size not set.  Driver may not function\n");
 
         if (ent->driver_data == sil_3114) {
                 irq_mask = SIL_MASK_4PORT;
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index 32d730bd5bb6..c66548025657 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include <scsi/scsi_host.h>
 #include "scsi.h"
 #include <linux/libata.h>
@@ -220,12 +221,11 @@ struct sil24_port_priv {
 
 /* ap->host_set->private_data */
 struct sil24_host_priv {
-        void *host_base;        /* global controller control (128 bytes @BAR0) */
-        void *port_base;        /* port registers (4 * 8192 bytes @BAR2) */
+        void __iomem *host_base;        /* global controller control (128 bytes @BAR0) */
+        void __iomem *port_base;        /* port registers (4 * 8192 bytes @BAR2) */
 };
 
 static u8 sil24_check_status(struct ata_port *ap);
-static u8 sil24_check_err(struct ata_port *ap);
 static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg);
 static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
 static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
@@ -280,7 +280,6 @@ static const struct ata_port_operations sil24_ops = {
 
         .check_status           = sil24_check_status,
         .check_altstatus        = sil24_check_status,
-        .check_err              = sil24_check_err,
         .dev_select             = ata_noop_dev_select,
 
         .tf_read                = sil24_tf_read,
@@ -349,10 +348,12 @@ static struct ata_port_info sil24_port_info[] = {
 static inline void sil24_update_tf(struct ata_port *ap)
 {
         struct sil24_port_priv *pp = ap->private_data;
-        void *port = (void *)ap->ioaddr.cmd_addr;
-        struct sil24_prb *prb = port;
+        void __iomem *port = (void __iomem *)ap->ioaddr.cmd_addr;
+        struct sil24_prb __iomem *prb = port;
+        u8 fis[6 * 4];
 
-        ata_tf_from_fis(prb->fis, &pp->tf);
+        memcpy_fromio(fis, prb->fis, 6 * 4);
+        ata_tf_from_fis(fis, &pp->tf);
 }
 
 static u8 sil24_check_status(struct ata_port *ap)
@@ -361,12 +362,6 @@ static u8 sil24_check_status(struct ata_port *ap)
         return pp->tf.command;
 }
 
-static u8 sil24_check_err(struct ata_port *ap)
-{
-        struct sil24_port_priv *pp = ap->private_data;
-        return pp->tf.feature;
-}
-
 static int sil24_scr_map[] = {
         [SCR_CONTROL]   = 0,
         [SCR_STATUS]    = 1,
@@ -376,9 +371,9 @@ static int sil24_scr_map[] = {
 
 static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg)
 {
-        void *scr_addr = (void *)ap->ioaddr.scr_addr;
+        void __iomem *scr_addr = (void __iomem *)ap->ioaddr.scr_addr;
         if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
-                void *addr;
+                void __iomem *addr;
                 addr = scr_addr + sil24_scr_map[sc_reg] * 4;
                 return readl(scr_addr + sil24_scr_map[sc_reg] * 4);
         }
@@ -387,9 +382,9 @@ static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg)
 
 static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
 {
-        void *scr_addr = (void *)ap->ioaddr.scr_addr;
+        void __iomem *scr_addr = (void __iomem *)ap->ioaddr.scr_addr;
         if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
-                void *addr;
+                void __iomem *addr;
                 addr = scr_addr + sil24_scr_map[sc_reg] * 4;
                 writel(val, scr_addr + sil24_scr_map[sc_reg] * 4);
         }
@@ -454,7 +449,7 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
 static int sil24_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
-        void *port = (void *)ap->ioaddr.cmd_addr;
+        void __iomem *port = (void __iomem *)ap->ioaddr.cmd_addr;
         struct sil24_port_priv *pp = ap->private_data;
         dma_addr_t paddr = pp->cmd_block_dma + qc->tag * sizeof(*pp->cmd_block);
 
@@ -467,7 +462,7 @@ static void sil24_irq_clear(struct ata_port *ap)
         /* unused */
 }
 
-static int __sil24_reset_controller(void *port)
+static int __sil24_reset_controller(void __iomem *port)
 {
         int cnt;
         u32 tmp;
@@ -493,7 +488,7 @@ static void sil24_reset_controller(struct ata_port *ap)
 {
         printk(KERN_NOTICE DRV_NAME
                " ata%u: resetting controller...\n", ap->id);
-        if (__sil24_reset_controller((void *)ap->ioaddr.cmd_addr))
+        if (__sil24_reset_controller((void __iomem *)ap->ioaddr.cmd_addr))
                 printk(KERN_ERR DRV_NAME
                        " ata%u: failed to reset controller\n", ap->id);
 }
@@ -504,7 +499,7 @@ static void sil24_eng_timeout(struct ata_port *ap)
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
         if (!qc) {
-                printk(KERN_ERR "ata%u: BUG: tiemout without command\n",
+                printk(KERN_ERR "ata%u: BUG: timeout without command\n",
                        ap->id);
                 return;
         }
@@ -518,7 +513,7 @@ static void sil24_eng_timeout(struct ata_port *ap)
          */
         printk(KERN_ERR "ata%u: command timeout\n", ap->id);
         qc->scsidone = scsi_finish_command;
-        ata_qc_complete(qc, ATA_ERR);
+        ata_qc_complete(qc, AC_ERR_OTHER);
 
         sil24_reset_controller(ap);
 }
@@ -527,8 +522,9 @@ static void sil24_error_intr(struct ata_port *ap, u32 slot_stat)
 {
         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
         struct sil24_port_priv *pp = ap->private_data;
-        void *port = (void *)ap->ioaddr.cmd_addr;
+        void __iomem *port = (void __iomem *)ap->ioaddr.cmd_addr;
         u32 irq_stat, cmd_err, sstatus, serror;
+        unsigned int err_mask;
 
         irq_stat = readl(port + PORT_IRQ_STAT);
         writel(irq_stat, port + PORT_IRQ_STAT);         /* clear irq */
@@ -556,17 +552,18 @@ static void sil24_error_intr(struct ata_port *ap, u32 slot_stat)
                  * Device is reporting error, tf registers are valid.
                  */
                 sil24_update_tf(ap);
+                err_mask = ac_err_mask(pp->tf.command);
         } else {
                 /*
                  * Other errors.  libata currently doesn't have any
                  * mechanism to report these errors.  Just turn on
                  * ATA_ERR.
                  */
-                pp->tf.command = ATA_ERR;
+                err_mask = AC_ERR_OTHER;
         }
 
         if (qc)
-                ata_qc_complete(qc, pp->tf.command);
+                ata_qc_complete(qc, err_mask);
 
         sil24_reset_controller(ap);
 }
@@ -574,7 +571,7 @@ static void sil24_error_intr(struct ata_port *ap, u32 slot_stat)
 static inline void sil24_host_intr(struct ata_port *ap)
 {
         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
-        void *port = (void *)ap->ioaddr.cmd_addr;
+        void __iomem *port = (void __iomem *)ap->ioaddr.cmd_addr;
         u32 slot_stat;
 
         slot_stat = readl(port + PORT_SLOT_STAT);
@@ -591,7 +588,7 @@ static inline void sil24_host_intr(struct ata_port *ap)
                 sil24_update_tf(ap);
 
                 if (qc)
-                        ata_qc_complete(qc, pp->tf.command);
+                        ata_qc_complete(qc, ac_err_mask(pp->tf.command));
         } else
                 sil24_error_intr(ap, slot_stat);
 }
@@ -689,11 +686,12 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         struct ata_port_info *pinfo = &sil24_port_info[board_id];
         struct ata_probe_ent *probe_ent = NULL;
         struct sil24_host_priv *hpriv = NULL;
-        void *host_base = NULL, *port_base = NULL;
+        void __iomem *host_base = NULL;
+        void __iomem *port_base = NULL;
         int i, rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
@@ -753,14 +751,14 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
          */
         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME "(%s): 32-bit DMA enable failed\n",
-                       pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "32-bit DMA enable failed\n");
                 goto out_free;
         }
         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
         if (rc) {
-                printk(KERN_ERR DRV_NAME "(%s): 32-bit consistent DMA enable failed\n",
-                       pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "32-bit consistent DMA enable failed\n");
                 goto out_free;
         }
 
@@ -771,7 +769,7 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         writel(0, host_base + HOST_CTRL);
 
         for (i = 0; i < probe_ent->n_ports; i++) {
-                void *port = port_base + i * PORT_REGS_SIZE;
+                void __iomem *port = port_base + i * PORT_REGS_SIZE;
                 unsigned long portu = (unsigned long)port;
                 u32 tmp;
                 int cnt;
@@ -796,9 +794,8 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                                         break;
                         }
                         if (tmp & PORT_CS_PORT_RST)
-                                printk(KERN_ERR DRV_NAME
-                                       "(%s): failed to clear port RST\n",
-                                       pci_name(pdev));
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "failed to clear port RST\n");
                 }
 
                 /* Zero error counters. */
@@ -827,9 +824,8 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
                 /* Reset itself */
                 if (__sil24_reset_controller(port))
-                        printk(KERN_ERR DRV_NAME
-                               "(%s): failed to reset controller\n",
-                               pci_name(pdev));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "failed to reset controller\n");
         }
 
         /* Turn on interrupts */
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index 057f7b98b6c4..42288be0e561 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -38,6 +38,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -237,6 +238,7 @@ static void sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 
 static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
+        static int printed_version;
         struct ata_probe_ent *probe_ent = NULL;
         int rc;
         u32 genctl;
@@ -245,6 +247,9 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 pmr;
         u8 port2_start;
 
+        if (!printed_version++)
+                dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
+
         rc = pci_enable_device(pdev);
         if (rc)
                 return rc;
@@ -288,16 +293,18 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         pci_read_config_byte(pdev, SIS_PMR, &pmr);
         if (ent->device != 0x182) {
                 if ((pmr & SIS_PMR_COMBINED) == 0) {
-                        printk(KERN_INFO "sata_sis: Detected SiS 180/181 chipset in SATA mode\n");
+                        dev_printk(KERN_INFO, &pdev->dev,
+                                   "Detected SiS 180/181 chipset in SATA mode\n");
                         port2_start = 64;
                 }
                 else {
-                        printk(KERN_INFO "sata_sis: Detected SiS 180/181 chipset in combined mode\n");
+                        dev_printk(KERN_INFO, &pdev->dev,
+                                   "Detected SiS 180/181 chipset in combined mode\n");
                         port2_start=0;
                 }
         }
         else {
-                printk(KERN_INFO "sata_sis: Detected SiS 182 chipset\n");
+                dev_printk(KERN_INFO, &pdev->dev, "Detected SiS 182 chipset\n");
                 port2_start = 0x20;
         }
 
diff --git a/drivers/scsi/sata_svw.c b/drivers/scsi/sata_svw.c
index e0f9570bc6dd..db615ff794d8 100644
--- a/drivers/scsi/sata_svw.c
+++ b/drivers/scsi/sata_svw.c
@@ -44,6 +44,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -84,6 +85,8 @@
 /* Port stride */
 #define K2_SATA_PORT_OFFSET             0x100
 
+static u8 k2_stat_check_status(struct ata_port *ap);
+
 
 static u32 k2_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
@@ -136,16 +139,24 @@ static void k2_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 static void k2_sata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
-        u16 nsect, lbal, lbam, lbah;
+        u16 nsect, lbal, lbam, lbah, feature;
 
-        nsect = tf->nsect = readw(ioaddr->nsect_addr);
-        lbal = tf->lbal = readw(ioaddr->lbal_addr);
-        lbam = tf->lbam = readw(ioaddr->lbam_addr);
-        lbah = tf->lbah = readw(ioaddr->lbah_addr);
+        tf->command = k2_stat_check_status(ap);
         tf->device = readw(ioaddr->device_addr);
+        feature = readw(ioaddr->error_addr);
+        nsect = readw(ioaddr->nsect_addr);
+        lbal = readw(ioaddr->lbal_addr);
+        lbam = readw(ioaddr->lbam_addr);
+        lbah = readw(ioaddr->lbah_addr);
+
+        tf->feature = feature;
+        tf->nsect = nsect;
+        tf->lbal = lbal;
+        tf->lbam = lbam;
+        tf->lbah = lbah;
 
         if (tf->flags & ATA_TFLAG_LBA48) {
-                tf->hob_feature = readw(ioaddr->error_addr) >> 8;
+                tf->hob_feature = feature >> 8;
                 tf->hob_nsect = nsect >> 8;
                 tf->hob_lbal = lbal >> 8;
                 tf->hob_lbam = lbam >> 8;
@@ -352,7 +363,7 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         int i;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index af08f4f650c1..0ec21e09f5d8 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -38,6 +38,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -718,7 +719,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
                         VPRINTK("ata%u: read hdma, 0x%x 0x%x\n", ap->id,
                                 readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
                         /* get drive status; clear intr; complete txn */
-                        ata_qc_complete(qc, ata_wait_idle(ap));
+                        ata_qc_complete(qc, ac_err_mask(ata_wait_idle(ap)));
                         pdc20621_pop_hdma(qc);
                 }
 
@@ -756,7 +757,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
                         VPRINTK("ata%u: write ata, 0x%x 0x%x\n", ap->id,
                                 readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
                         /* get drive status; clear intr; complete txn */
-                        ata_qc_complete(qc, ata_wait_idle(ap));
+                        ata_qc_complete(qc, ac_err_mask(ata_wait_idle(ap)));
                         pdc20621_pop_hdma(qc);
                 }
                 handled = 1;
@@ -766,7 +767,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
 
                 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
                 DPRINTK("BUS_NODATA (drv_stat 0x%X)\n", status);
-                ata_qc_complete(qc, status);
+                ata_qc_complete(qc, ac_err_mask(status));
                 handled = 1;
 
         } else {
@@ -881,7 +882,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
         case ATA_PROT_DMA:
         case ATA_PROT_NODATA:
                 printk(KERN_ERR "ata%u: command timeout\n", ap->id);
-                ata_qc_complete(qc, ata_wait_idle(ap) | ATA_ERR);
+                ata_qc_complete(qc, __ac_err_mask(ata_wait_idle(ap)));
                 break;
 
         default:
@@ -890,7 +891,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
                 printk(KERN_ERR "ata%u: unknown timeout, cmd 0x%x stat 0x%x\n",
                        ap->id, qc->tf.command, drv_stat);
 
-                ata_qc_complete(qc, drv_stat);
+                ata_qc_complete(qc, ac_err_mask(drv_stat));
                 break;
         }
 
@@ -1385,7 +1386,7 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         int rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         /*
          * If this driver happens to only be useful on Apple's K2, then
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index d68dc7d3422c..a5e245c098e1 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -32,6 +32,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -178,12 +179,16 @@ static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 
 static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
+        static int printed_version;
         struct ata_probe_ent *probe_ent;
         struct ata_port_info *ppi;
         int rc;
         unsigned int board_idx = (unsigned int) ent->driver_data;
         int pci_dev_busy = 0;
 
+        if (!printed_version++)
+                dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
+
         rc = pci_enable_device(pdev);
         if (rc)
                 return rc;
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index 80e291a909a9..b3ecdbe400e9 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -41,6 +41,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -259,15 +260,15 @@ static void svia_configure(struct pci_dev *pdev)
         u8 tmp8;
 
         pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
-        printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
-               pci_name(pdev),
+        dev_printk(KERN_INFO, &pdev->dev, "routed to hard irq line %d\n",
                (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
 
         /* make sure SATA channels are enabled */
         pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
         if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
-                printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
-                       pci_name(pdev), (int) tmp8);
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "enabling SATA channels (0x%x)\n",
+                           (int) tmp8);
                 tmp8 |= ALL_PORTS;
                 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
         }
@@ -275,8 +276,9 @@ static void svia_configure(struct pci_dev *pdev)
         /* make sure interrupts for each channel sent to us */
         pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
         if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
-                printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
-                       pci_name(pdev), (int) tmp8);
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "enabling SATA channel interrupts (0x%x)\n",
+                           (int) tmp8);
                 tmp8 |= ALL_PORTS;
                 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
         }
@@ -284,8 +286,9 @@ static void svia_configure(struct pci_dev *pdev)
         /* make sure native mode is enabled */
         pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
         if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
-                printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
-                       pci_name(pdev), (int) tmp8);
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "enabling SATA channel native mode (0x%x)\n",
+                           (int) tmp8);
                 tmp8 |= NATIVE_MODE_ALL;
                 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
         }
@@ -303,7 +306,7 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         u8 tmp8;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
@@ -318,8 +321,9 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (board_id == vt6420) {
                 pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
                 if (tmp8 & SATA_2DEV) {
-                        printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
-                        pci_name(pdev), (int) tmp8);
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "SATA master/slave not supported (0x%x)\n",
+                                   (int) tmp8);
                         rc = -EIO;
                         goto err_out_regions;
                 }
@@ -332,10 +336,11 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
                 if ((pci_resource_start(pdev, i) == 0) ||
                     (pci_resource_len(pdev, i) < bar_sizes[i])) {
-                        printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
-                               pci_name(pdev), i,
-                               pci_resource_start(pdev, i),
-                               pci_resource_len(pdev, i));
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
+                                   i,
+                                   pci_resource_start(pdev, i),
+                                   pci_resource_len(pdev, i));
                         rc = -ENODEV;
                         goto err_out_regions;
                 }
@@ -353,8 +358,7 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 probe_ent = vt6421_init_probe_ent(pdev);
 
         if (!probe_ent) {
-                printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
-                       pci_name(pdev));
+                dev_printk(KERN_ERR, &pdev->dev, "out of memory\n");
                 rc = -ENOMEM;
                 goto err_out_regions;
         }
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 5af05fdf8544..bb84ba0c7e83 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -42,6 +42,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
+#include <linux/device.h>
 #include "scsi.h"
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
@@ -153,16 +154,24 @@ static void vsc_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 static void vsc_sata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
-        u16 nsect, lbal, lbam, lbah;
+        u16 nsect, lbal, lbam, lbah, feature;
 
-        nsect = tf->nsect = readw(ioaddr->nsect_addr);
-        lbal = tf->lbal = readw(ioaddr->lbal_addr);
-        lbam = tf->lbam = readw(ioaddr->lbam_addr);
-        lbah = tf->lbah = readw(ioaddr->lbah_addr);
+        tf->command = ata_check_status(ap);
         tf->device = readw(ioaddr->device_addr);
+        feature = readw(ioaddr->error_addr);
+        nsect = readw(ioaddr->nsect_addr);
+        lbal = readw(ioaddr->lbal_addr);
+        lbam = readw(ioaddr->lbam_addr);
+        lbah = readw(ioaddr->lbah_addr);
+
+        tf->feature = feature;
+        tf->nsect = nsect;
+        tf->lbal = lbal;
+        tf->lbam = lbam;
+        tf->lbah = lbah;
 
         if (tf->flags & ATA_TFLAG_LBA48) {
-                tf->hob_feature = readb(ioaddr->error_addr);
+                tf->hob_feature = feature >> 8;
                 tf->hob_nsect = nsect >> 8;
                 tf->hob_lbal = lbal >> 8;
                 tf->hob_lbam = lbam >> 8;
@@ -287,7 +296,7 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
         int rc;
 
         if (!printed_version++)
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
         rc = pci_enable_device(pdev);
         if (rc)
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 771e97ef136e..b856e140e65f 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -26,6 +26,7 @@
  */
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/sched.h>        /* workqueue stuff, HZ */
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 8bb8222ea589..d2caa35059d9 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -19,6 +19,9 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 #include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 861e51375d70..d86d5c26061d 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -49,6 +49,7 @@ static int sg_version_num = 30533;	/* 2 digits for each component */
 #include <linux/seq_file.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/scatterlist.h>
 
 #include "scsi.h"
 #include <scsi/scsi_dbg.h>
@@ -1886,13 +1887,17 @@ st_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
         int i;
 
         for (i=0; i < nr_pages; i++) {
-                if (dirtied && !PageReserved(sgl[i].page))
-                        SetPageDirty(sgl[i].page);
-                /* unlock_page(sgl[i].page); */
+                struct page *page = sgl[i].page;
+
+                /* XXX: just for debug. Remove when PageReserved is removed */
+                BUG_ON(PageReserved(page));
+                if (dirtied)
+                        SetPageDirty(page);
+                /* unlock_page(page); */
                 /* FIXME: cache flush missing for rw==READ
                  * FIXME: call the correct reference counting function
                  */
-                page_cache_release(sgl[i].page);
+                page_cache_release(page);
         }
 
         return 0;
@@ -1992,9 +1997,7 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
                                 if (!p)
                                         break;
                         }
-                        sclp->page = virt_to_page(p);
-                        sclp->offset = offset_in_page(p);
-                        sclp->length = ret_sz;
+                        sg_set_buf(sclp, p, ret_sz);
 
                         SCSI_LOG_TIMEOUT(5, printk("sg_build_build: k=%d, a=0x%p, len=%d\n",
                                           k, sg_scatg2virt(sclp), ret_sz));
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 5eb54d8019b4..da9766283bd7 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -4526,12 +4526,16 @@ static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_p
         int i;
 
         for (i=0; i < nr_pages; i++) {
-                if (dirtied && !PageReserved(sgl[i].page))
-                        SetPageDirty(sgl[i].page);
+                struct page *page = sgl[i].page;
+
+                /* XXX: just for debug. Remove when PageReserved is removed */
+                BUG_ON(PageReserved(page));
+                if (dirtied)
+                        SetPageDirty(page);
                 /* FIXME: cache flush missing for rw==READ
                  * FIXME: call the correct reference counting function
                  */
-                page_cache_release(sgl[i].page);
+                page_cache_release(page);
         }
 
         return 0;
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index e753ba27dc59..a1a58e1d5ad3 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -37,6 +37,9 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+
+#include <linux/slab.h>
+
 #include "sym_glue.h"
 #include "sym_nvram.h"
 
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.h b/drivers/scsi/sym53c8xx_2/sym_hipd.h
index 3131a6bf7ab7..3a264a408216 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.h
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.h
@@ -37,6 +37,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <linux/gfp.h>
+
 #ifndef SYM_HIPD_H
 #define SYM_HIPD_H
 
diff --git a/drivers/serial/ioc4_serial.c b/drivers/serial/ioc4_serial.c
index f88fdd480685..771676abee60 100644
--- a/drivers/serial/ioc4_serial.c
+++ b/drivers/serial/ioc4_serial.c
@@ -308,6 +308,8 @@ struct ioc4_serial {
 typedef void ioc4_intr_func_f(void *, uint32_t);
 typedef ioc4_intr_func_f *ioc4_intr_func_t;
 
+static unsigned int Num_of_ioc4_cards;
+
 /* defining this will get you LOTS of great debug info */
 //#define DEBUG_INTERRUPTS
 #define DPRINT_CONFIG(_x...)    ;
@@ -317,7 +319,8 @@ typedef ioc4_intr_func_f *ioc4_intr_func_t;
 #define WAKEUP_CHARS    256
 
 /* number of characters we want to transmit to the lower level at a time */
-#define IOC4_MAX_CHARS  128
+#define IOC4_MAX_CHARS  256
+#define IOC4_FIFO_CHARS 255
 
 /* Device name we're using */
 #define DEVICE_NAME     "ttyIOC"
@@ -1038,6 +1041,7 @@ static int inline ioc4_attach_local(struct ioc4_driver_data *idd)
                         return -ENOMEM;
                 }
                 memset(port, 0, sizeof(struct ioc4_port));
+                spin_lock_init(&port->ip_lock);
 
                 /* we need to remember the previous ones, to point back to
                  * them farther down - setting up the ring buffers.
@@ -1691,12 +1695,14 @@ ioc4_change_speed(struct uart_port *the_port,
                 baud = 9600;
 
         if (!the_port->fifosize)
-                the_port->fifosize = IOC4_MAX_CHARS;
+                the_port->fifosize = IOC4_FIFO_CHARS;
         the_port->timeout = ((the_port->fifosize * HZ * bits) / (baud / 10));
         the_port->timeout += HZ / 50;   /* Add .02 seconds of slop */
 
         the_port->ignore_status_mask = N_ALL_INPUT;
 
+        info->tty->low_latency = 1;
+
         if (I_IGNPAR(info->tty))
                 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
                                                 | N_FRAMING_ERROR);
@@ -1742,7 +1748,6 @@ ioc4_change_speed(struct uart_port *the_port,
  */
 static inline int ic4_startup_local(struct uart_port *the_port)
 {
-        int retval = 0;
         struct ioc4_port *port;
         struct uart_info *info;
 
@@ -1754,9 +1759,6 @@ static inline int ic4_startup_local(struct uart_port *the_port)
                 return -1;
 
         info = the_port->info;
-        if (info->flags & UIF_INITIALIZED) {
-                return retval;
-        }
 
         if (info->tty) {
                 set_bit(TTY_IO_ERROR, &info->tty->flags);
@@ -1775,7 +1777,6 @@ static inline int ic4_startup_local(struct uart_port *the_port)
         /* set the speed of the serial port */
         ioc4_change_speed(the_port, info->tty->termios, (struct termios *)0);
 
-        info->flags |= UIF_INITIALIZED;
         return 0;
 }
 
@@ -1785,9 +1786,13 @@ static inline int ic4_startup_local(struct uart_port *the_port)
  */
 static void ioc4_cb_output_lowat(struct ioc4_port *port)
 {
+        unsigned long pflags;
+
         /* ip_lock is set on the call here */
         if (port->ip_port) {
+                spin_lock_irqsave(&port->ip_port->lock, pflags);
                 transmit_chars(port->ip_port);
+                spin_unlock_irqrestore(&port->ip_port->lock, pflags);
         }
 }
 
@@ -2064,8 +2069,7 @@ static inline int do_read(struct uart_port *the_port, unsigned char *buf,
          * available data as long as it returns some.
          */
         /* Re-arm the timer */
-        writel(port->ip_rx_cons | IOC4_SRCIR_ARM,
-                        &port->ip_serial_regs->srcir);
+        writel(port->ip_rx_cons | IOC4_SRCIR_ARM, &port->ip_serial_regs->srcir);
 
         prod_ptr = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
         cons_ptr = port->ip_rx_cons;
@@ -2299,6 +2303,7 @@ static inline int do_read(struct uart_port *the_port, unsigned char *buf,
         }
         return total;
 }
+
 /**
  * receive_chars - upper level read. Called with ip_lock.
  * @the_port: port to read from
@@ -2307,9 +2312,11 @@ static void receive_chars(struct uart_port *the_port)
 {
         struct tty_struct *tty;
         unsigned char ch[IOC4_MAX_CHARS];
-        int read_count, request_count;
+        int read_count, request_count = IOC4_MAX_CHARS;
         struct uart_icount *icount;
         struct uart_info *info = the_port->info;
+        int flip = 0;
+        unsigned long pflags;
 
         /* Make sure all the pointers are "good" ones */
         if (!info)
@@ -2317,16 +2324,17 @@ static void receive_chars(struct uart_port *the_port)
         if (!info->tty)
                 return;
 
+        spin_lock_irqsave(&the_port->lock, pflags);
         tty = info->tty;
 
-        request_count = TTY_FLIPBUF_SIZE - tty->flip.count - 1;
+        if (request_count > TTY_FLIPBUF_SIZE - tty->flip.count)
+                request_count = TTY_FLIPBUF_SIZE - tty->flip.count;
 
         if (request_count > 0) {
-                if (request_count > IOC4_MAX_CHARS - 2)
-                        request_count = IOC4_MAX_CHARS - 2;
                 icount = &the_port->icount;
                 read_count = do_read(the_port, ch, request_count);
                 if (read_count > 0) {
+                        flip = 1;
                         memcpy(tty->flip.char_buf_ptr, ch, read_count);
                         memset(tty->flip.flag_buf_ptr, TTY_NORMAL, read_count);
                         tty->flip.char_buf_ptr += read_count;
@@ -2335,7 +2343,11 @@ static void receive_chars(struct uart_port *the_port)
                         icount->rx += read_count;
                 }
         }
-        tty_flip_buffer_push(tty);
+
+        spin_unlock_irqrestore(&the_port->lock, pflags);
+
+        if (flip)
+                tty_flip_buffer_push(tty);
 }
 
 /**
@@ -2393,18 +2405,14 @@ static void ic4_shutdown(struct uart_port *the_port)
 
         info = the_port->info;
 
-        if (!(info->flags & UIF_INITIALIZED))
-                return;
-
         wake_up_interruptible(&info->delta_msr_wait);
 
         if (info->tty)
                 set_bit(TTY_IO_ERROR, &info->tty->flags);
 
-        spin_lock_irqsave(&port->ip_lock, port_flags);
+        spin_lock_irqsave(&the_port->lock, port_flags);
         set_notification(port, N_ALL, 0);
-        info->flags &= ~UIF_INITIALIZED;
-        spin_unlock_irqrestore(&port->ip_lock, port_flags);
+        spin_unlock_irqrestore(&the_port->lock, port_flags);
 }
 
 /**
@@ -2463,12 +2471,10 @@ static unsigned int ic4_get_mctrl(struct uart_port *the_port)
 static void ic4_start_tx(struct uart_port *the_port)
 {
         struct ioc4_port *port = get_ioc4_port(the_port);
-        unsigned long flags;
 
         if (port) {
-                spin_lock_irqsave(&port->ip_lock, flags);
-                transmit_chars(the_port);
-                spin_unlock_irqrestore(&port->ip_lock, flags);
+                set_notification(port, N_OUTPUT_LOWAT, 1);
+                enable_intrs(port, port->ip_hooks->intr_tx_mt);
         }
 }
 
@@ -2510,9 +2516,9 @@ static int ic4_startup(struct uart_port *the_port)
         }
 
         /* Start up the serial port */
-        spin_lock_irqsave(&port->ip_lock, port_flags);
+        spin_lock_irqsave(&the_port->lock, port_flags);
         retval = ic4_startup_local(the_port);
-        spin_unlock_irqrestore(&port->ip_lock, port_flags);
+        spin_unlock_irqrestore(&the_port->lock, port_flags);
         return retval;
 }
 
@@ -2527,12 +2533,11 @@ static void
 ic4_set_termios(struct uart_port *the_port,
                 struct termios *termios, struct termios *old_termios)
 {
-        struct ioc4_port *port = get_ioc4_port(the_port);
         unsigned long port_flags;
 
-        spin_lock_irqsave(&port->ip_lock, port_flags);
+        spin_lock_irqsave(&the_port->lock, port_flags);
         ioc4_change_speed(the_port, termios, old_termios);
-        spin_unlock_irqrestore(&port->ip_lock, port_flags);
+        spin_unlock_irqrestore(&the_port->lock, port_flags);
 }
 
 /**
@@ -2607,24 +2612,25 @@ ioc4_serial_core_attach(struct pci_dev *pdev)
                                 __FUNCTION__, (void *)the_port,
                                 (void *)port));
 
-                spin_lock_init(&the_port->lock);
                 /* membase, iobase and mapbase just need to be non-0 */
                 the_port->membase = (unsigned char __iomem *)1;
-                the_port->line = the_port->iobase = ii;
+                the_port->iobase = (pdev->bus->number << 16) |  ii;
+                the_port->line = (Num_of_ioc4_cards << 2) | ii;
                 the_port->mapbase = 1;
                 the_port->type = PORT_16550A;
-                the_port->fifosize = IOC4_MAX_CHARS;
+                the_port->fifosize = IOC4_FIFO_CHARS;
                 the_port->ops = &ioc4_ops;
                 the_port->irq = control->ic_irq;
                 the_port->dev = &pdev->dev;
+                spin_lock_init(&the_port->lock);
                 if (uart_add_one_port(&ioc4_uart, the_port) < 0) {
                         printk(KERN_WARNING
-                                       "%s: unable to add port %d\n",
-                                       __FUNCTION__, the_port->line);
+                           "%s: unable to add port %d bus %d\n",
+                               __FUNCTION__, the_port->line, pdev->bus->number);
                 } else {
                         DPRINT_CONFIG(
-                                    ("IOC4 serial driver port %d irq = %d\n",
-                                       the_port->line, the_port->irq));
+                            ("IOC4 serial port %d irq = %d, bus %d\n",
+                               the_port->line, the_port->irq, pdev->bus->number));
                 }
                 /* all ports are rs232 for now */
                 ioc4_set_proto(port, PROTO_RS232);
@@ -2734,6 +2740,8 @@ ioc4_serial_attach_one(struct ioc4_driver_data *idd)
         if ((ret = ioc4_serial_core_attach(idd->idd_pdev)))
                 goto out4;
 
+        Num_of_ioc4_cards++;
+
         return ret;
 
         /* error exits that give back resources */
diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
index f4c709bc464b..ba8838b234da 100644
--- a/drivers/serial/mpsc.c
+++ b/drivers/serial/mpsc.c
@@ -1102,6 +1102,8 @@ mpsc_start_rx(struct mpsc_port_info *pi)
 {
         pr_debug("mpsc_start_rx[%d]: Starting...\n", pi->port.line);
 
+        /* Issue a Receive Abort to clear any receive errors */
+        writel(MPSC_CHR_2_RA, pi->mpsc_base + MPSC_CHR_2);
         if (pi->rcv_data) {
                 mpsc_enter_hunt(pi);
                 mpsc_sdma_cmd(pi, SDMA_SDCM_ERD);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 2d8622eef701..401d94a7fe2e 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -147,8 +147,7 @@ static int uart_startup(struct uart_state *state, int init_hw)
          * once we have successfully opened the port.  Also set
          * up the tty->alt_speed kludge
          */
-        if (info->tty)
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
+        set_bit(TTY_IO_ERROR, &info->tty->flags);
 
         if (port->type == PORT_UNKNOWN)
                 return 0;
diff --git a/drivers/sh/superhyway/superhyway.c b/drivers/sh/superhyway/superhyway.c
index f056276b08a1..28757cb9d246 100644
--- a/drivers/sh/superhyway/superhyway.c
+++ b/drivers/sh/superhyway/superhyway.c
@@ -16,6 +16,8 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/superhyway.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 
 static int superhyway_devices;
 
diff --git a/drivers/tc/tc.c b/drivers/tc/tc.c
index a89ef4df80c3..a0e5af638e0e 100644
--- a/drivers/tc/tc.c
+++ b/drivers/tc/tc.c
@@ -8,33 +8,31 @@
  * for more details.
  *
  * Copyright (c) Harald Koerfgen, 1998
- * Copyright (c) 2001, 2003  Maciej W. Rozycki
+ * Copyright (c) 2001, 2003, 2005  Maciej W. Rozycki
  */
-#include <linux/string.h>
 #include <linux/init.h>
-#include <linux/ioport.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/string.h>
+#include <linux/types.h>
 
 #include <asm/addrspace.h>
+#include <asm/bug.h>
 #include <asm/errno.h>
+#include <asm/io.h>
+#include <asm/paccess.h>
+
 #include <asm/dec/machtype.h>
 #include <asm/dec/prom.h>
 #include <asm/dec/tcinfo.h>
 #include <asm/dec/tcmodule.h>
 #include <asm/dec/interrupts.h>
-#include <asm/paccess.h>
-#include <asm/ptrace.h>
-
-#define TC_DEBUG
 
 MODULE_LICENSE("GPL");
 slot_info tc_bus[MAX_SLOT];
 static int num_tcslots;
 static tcinfo *info;
 
-unsigned long system_base;
-
 /*
  * Interface to the world. Read comment in include/asm-mips/tc.h.
  */
@@ -97,13 +95,16 @@ unsigned long get_tc_speed(void)
 static void __init tc_probe(unsigned long startaddr, unsigned long size,
                             int slots)
 {
+        unsigned long slotaddr;
         int i, slot, err;
         long offset;
-        unsigned char pattern[4];
-        unsigned char *module;
+        u8 pattern[4];
+        volatile u8 *module;
 
         for (slot = 0; slot < slots; slot++) {
-                module = (char *)(startaddr + slot * size);
+                slotaddr = startaddr + slot * size;
+                module = ioremap_nocache(slotaddr, size);
+                BUG_ON(!module);
 
                 offset = OLDCARD;
 
@@ -112,8 +113,10 @@ static void __init tc_probe(unsigned long startaddr, unsigned long size,
                 err |= get_dbe(pattern[1], module + OLDCARD + TC_PATTERN1);
                 err |= get_dbe(pattern[2], module + OLDCARD + TC_PATTERN2);
                 err |= get_dbe(pattern[3], module + OLDCARD + TC_PATTERN3);
-                if (err)
+                if (err) {
+                        iounmap(module);
                         continue;
+                }
 
                 if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
                     pattern[2] != 0xaa || pattern[3] != 0xff) {
@@ -124,16 +127,20 @@ static void __init tc_probe(unsigned long startaddr, unsigned long size,
                         err |= get_dbe(pattern[1], module + TC_PATTERN1);
                         err |= get_dbe(pattern[2], module + TC_PATTERN2);
                         err |= get_dbe(pattern[3], module + TC_PATTERN3);
-                        if (err)
+                        if (err) {
+                                iounmap(module);
                                 continue;
+                        }
                 }
 
                 if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
-                    pattern[2] != 0xaa || pattern[3] != 0xff)
+                    pattern[2] != 0xaa || pattern[3] != 0xff) {
+                        iounmap(module);
                         continue;
+                }
 
-                tc_bus[slot].base_addr = (unsigned long)module;
-                for(i = 0; i < 8; i++) {
+                tc_bus[slot].base_addr = slotaddr;
+                for (i = 0; i < 8; i++) {
                         tc_bus[slot].firmware[i] =
                                 module[TC_FIRM_VER + offset + 4 * i];
                         tc_bus[slot].vendor[i] =
@@ -171,13 +178,15 @@ static void __init tc_probe(unsigned long startaddr, unsigned long size,
                         tc_bus[slot].interrupt = -1;
                         break;
                 }
+
+                iounmap(module);
         }
 }
 
 /*
  * the main entry
  */
-void __init tc_init(void)
+static int __init tc_init(void)
 {
         int tc_clock;
         int i;
@@ -185,7 +194,7 @@ void __init tc_init(void)
         unsigned long slot_size;
 
         if (!TURBOCHANNEL)
-                return;
+                return 0;
 
         for (i = 0; i < MAX_SLOT; i++) {
                 tc_bus[i].base_addr = 0;
@@ -196,8 +205,8 @@ void __init tc_init(void)
                 tc_bus[i].flags = FREE;
         }
 
-        info = (tcinfo *) rex_gettcinfo();
-        slot0addr = (unsigned long)KSEG1ADDR(rex_slot_address(0));
+        info = rex_gettcinfo();
+        slot0addr = CPHYSADDR((long)rex_slot_address(0));
 
         switch (mips_machtype) {
         case MACH_DS5000_200:
@@ -216,37 +225,24 @@ void __init tc_init(void)
 
         tc_clock = 10000 / info->clk_period;
 
-        if (TURBOCHANNEL && info->slot_size && slot0addr) {
-                printk("TURBOchannel rev. %1d at %2d.%1d MHz ", info->revision,
-                        tc_clock / 10, tc_clock % 10);
-                printk("(with%s parity)\n", info->parity ? "" : "out");
+        if (info->slot_size && slot0addr) {
+                pr_info("TURBOchannel rev. %d at %d.%d MHz (with%s parity)\n",
+                        info->revision, tc_clock / 10, tc_clock % 10,
+                        info->parity ? "" : "out");
 
                 slot_size = info->slot_size << 20;
 
                 tc_probe(slot0addr, slot_size, num_tcslots);
 
-                /*
-                 * All TURBOchannel DECstations have the onboard devices
-                 * where the (num_tcslots + 0 or 1 on DS5k/xx) Option Module
-                 * would be.
-                 */
-                if(mips_machtype == MACH_DS5000_XX)
-                        i = 1;
-                else
-                        i = 0;
-
-                system_base = slot0addr + slot_size * (num_tcslots + i);
-
-#ifdef TC_DEBUG
-                for (i = 0; i < num_tcslots; i++)
-                        if (tc_bus[i].base_addr) {
-                                printk("    slot %d: ", i);
-                                printk("%s %s %s\n", tc_bus[i].vendor,
-                                        tc_bus[i].name, tc_bus[i].firmware);
-                        }
-#endif
-                ioport_resource.end = KSEG2 - 1;
+                for (i = 0; i < num_tcslots; i++) {
+                        if (!tc_bus[i].base_addr)
+                                continue;
+                        pr_info("    slot %d: %s %s %s\n", i, tc_bus[i].vendor,
+                                tc_bus[i].name, tc_bus[i].firmware);
+                }
         }
+
+        return 0;
 }
 
 subsys_initcall(tc_init);
@@ -257,4 +253,3 @@ EXPORT_SYMBOL(release_tc_card);
 EXPORT_SYMBOL(get_tc_base_addr);
 EXPORT_SYMBOL(get_tc_irq_nr);
 EXPORT_SYMBOL(get_tc_speed);
-EXPORT_SYMBOL(system_base);
diff --git a/drivers/tc/zs.c b/drivers/tc/zs.c
index 6bed8713897e..c52af73a251b 100644
--- a/drivers/tc/zs.c
+++ b/drivers/tc/zs.c
@@ -65,14 +65,14 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/bootinfo.h>
-#include <asm/dec/serial.h>
 
-#ifdef CONFIG_MACH_DECSTATION
 #include <asm/dec/interrupts.h>
+#include <asm/dec/ioasic_addrs.h>
 #include <asm/dec/machtype.h>
+#include <asm/dec/serial.h>
+#include <asm/dec/system.h>
 #include <asm/dec/tc.h>
-#include <asm/dec/ioasic_addrs.h>
-#endif
+
 #ifdef CONFIG_KGDB
 #include <asm/kgdb.h>
 #endif
@@ -192,18 +192,6 @@ static void probe_sccs(void);
 static void change_speed(struct dec_serial *info);
 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 
-/*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char tmp_buf[4096]; /* This is cheating */
-static DECLARE_MUTEX(tmp_buf_sem);
-
 static inline int serial_paranoia_check(struct dec_serial *info,
                                         char *name, const char *routine)
 {
@@ -1628,30 +1616,22 @@ static void __init probe_sccs(void)
                 return;
         }
 
-        /*
-         * When serial console is activated, tc_init has not been called yet
-         * and system_base is undefined. Unfortunately we have to hardcode
-         * system_base for this case :-(. HK
-         */
         switch(mips_machtype) {
 #ifdef CONFIG_MACH_DECSTATION
         case MACH_DS5000_2X0:
         case MACH_DS5900:
-                system_base = KSEG1ADDR(0x1f800000);
                 n_chips = 2;
                 zs_parms = &ds_parms;
                 zs_parms->irq0 = dec_interrupt[DEC_IRQ_SCC0];
                 zs_parms->irq1 = dec_interrupt[DEC_IRQ_SCC1];
                 break;
         case MACH_DS5000_1XX:
-                system_base = KSEG1ADDR(0x1c000000);
                 n_chips = 2;
                 zs_parms = &ds_parms;
                 zs_parms->irq0 = dec_interrupt[DEC_IRQ_SCC0];
                 zs_parms->irq1 = dec_interrupt[DEC_IRQ_SCC1];
                 break;
         case MACH_DS5000_XX:
-                system_base = KSEG1ADDR(0x1c000000);
                 n_chips = 1;
                 zs_parms = &ds_parms;
                 zs_parms->irq0 = dec_interrupt[DEC_IRQ_SCC0];
@@ -1673,10 +1653,10 @@ static void __init probe_sccs(void)
                          * The sccs reside on the high byte of the 16 bit IOBUS
                          */
                         zs_channels[n_channels].control =
-                                (volatile unsigned char *)system_base +
+                                (volatile void *)CKSEG1ADDR(dec_kn_slot_base +
                           (0 == chip ? zs_parms->scc0 : zs_parms->scc1) +
                           (0 == channel ? zs_parms->channel_a_offset :
-                                          zs_parms->channel_b_offset);
+                                          zs_parms->channel_b_offset));
                         zs_channels[n_channels].data =
                                 zs_channels[n_channels].control + 4;
 
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 277bcb902d3b..e46cc540cf4d 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -14,6 +14,8 @@
  * This file is licenced under the GPL.
  */
 
+#include <linux/signal.h>       /* SA_INTERRUPT */
+#include <linux/jiffies.h>
 #include <linux/platform_device.h>
 
 #include <asm/hardware.h>
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index bf1d5ab4aa3a..7ce1d9ef0289 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -14,6 +14,8 @@
  * This file is licenced under the GPL.
  */
  
+#include <linux/jiffies.h>
+
 #ifdef CONFIG_PPC_PMAC
 #include <asm/machdep.h>
 #include <asm/pmac_feature.h>
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 5181999c56c9..59e20568e8f9 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -19,7 +19,10 @@
  * This file is licenced under the GPL.
  */
 
+#include <linux/device.h>
+#include <linux/signal.h>
 #include <linux/platform_device.h>
+
 #include <asm/mach-types.h>
 #include <asm/hardware.h>
 #include <asm/arch/pxa-regs.h>
diff --git a/drivers/usb/input/pid.c b/drivers/usb/input/pid.c
index a00672c96644..dca5ee93a4ef 100644
--- a/drivers/usb/input/pid.c
+++ b/drivers/usb/input/pid.c
@@ -198,7 +198,7 @@ static int hid_pid_upload_effect(struct input_dev *dev,
                 }
 
                 effect->id = id;
-                dev_dbg(&pid_private->hid->dev->dev, "effect ID is %d\n.", id);
+                dev_dbg(&pid_private->hid->dev->dev, "effect ID is %d.\n", id);
                 pid_private->effects[id].owner = current->pid;
                 pid_private->effects[id].flags = (1 << FF_PID_FLAGS_USED);
                 spin_unlock_irqrestore(&pid_private->lock, flags);
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index 3944a55ed74c..1dc3e0f73014 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -319,20 +319,8 @@ static ssize_t idmouse_read(struct file *file, char __user *buffer, size_t count
                 return -ENODEV;
         }
 
-        if (*ppos >= IMGSIZE) {
-                up (&dev->sem);
-                return 0;
-        }
-
-        count = min ((loff_t)count, IMGSIZE - (*ppos));
-
-        if (copy_to_user (buffer, dev->bulk_in_buffer + *ppos, count)) {
-                result = -EFAULT;
-        } else {
-                result = count;
-                *ppos += count;
-        }
-
+        result = simple_read_from_buffer(buffer, count, ppos,
+                                        dev->bulk_in_buffer, IMGSIZE);
         /* unlock the device */
         up(&dev->sem);
         return result;
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 90a96257d6ce..2997f558159b 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -9,7 +9,7 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 
 #include <linux/usb.h>
 
@@ -381,7 +381,6 @@ alloc_sglist (int nents, int max, int vary)
         sg = kmalloc (nents * sizeof *sg, SLAB_KERNEL);
         if (!sg)
                 return NULL;
-        memset (sg, 0, nents * sizeof *sg);
 
         for (i = 0; i < nents; i++) {
                 char            *buf;
@@ -394,9 +393,7 @@ alloc_sglist (int nents, int max, int vary)
                 memset (buf, 0, size);
 
                 /* kmalloc pages are always physically contiguous! */
-                sg [i].page = virt_to_page (buf);
-                sg [i].offset = offset_in_page (buf);
-                sg [i].length = size;
+                sg_init_one(&sg[i], buf, size);
 
                 if (vary) {
                         size += vary;
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 1cd942abb580..7192b770bfb6 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -494,7 +494,7 @@ config FB_TGA
 
 config FB_VESA
         bool "VESA VGA graphics support"
-        depends on (FB = y) && (X86 || X86_64)
+        depends on (FB = y) && X86
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -712,7 +712,7 @@ config FB_RIVA_DEBUG
 
 config FB_I810
         tristate "Intel 810/815 support (EXPERIMENTAL)"
-        depends on FB && EXPERIMENTAL && PCI && X86 && !X86_64
+        depends on FB && EXPERIMENTAL && PCI && X86_32
         select AGP
         select AGP_INTEL
         select FB_MODE_HELPERS
@@ -761,7 +761,7 @@ config FB_I810_I2C
 
 config FB_INTEL
         tristate "Intel 830M/845G/852GM/855GM/865G support (EXPERIMENTAL)"
-        depends on FB && EXPERIMENTAL && PCI && X86 && !X86_64
+        depends on FB && EXPERIMENTAL && PCI && X86_32
         select AGP
         select AGP_INTEL
         select FB_MODE_HELPERS
@@ -1376,7 +1376,7 @@ config FB_HIT
 
 config FB_PMAG_AA
         bool "PMAG-AA TURBOchannel framebuffer support"
-        depends on (FB = y) && MACH_DECSTATION && TC
+        depends on (FB = y) && TC
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -1387,7 +1387,7 @@ config FB_PMAG_AA
 
 config FB_PMAG_BA
         bool "PMAG-BA TURBOchannel framebuffer support"
-        depends on (FB = y) && MACH_DECSTATION && TC
+        depends on (FB = y) && TC
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -1398,7 +1398,7 @@ config FB_PMAG_BA
 
 config FB_PMAGB_B
         bool "PMAGB-B TURBOchannel framebuffer support"
-        depends on (FB = y) && MACH_DECSTATION && TC
+        depends on (FB = y) && TC
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -1410,7 +1410,7 @@ config FB_PMAGB_B
 
 config FB_MAXINE
         bool "Maxine (Personal DECstation) onboard framebuffer support"
-        depends on (FB = y) && MACH_DECSTATION && TC
+        depends on (FB = y) && MACH_DECSTATION
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 1fff29f48ca8..97c5d03ac8d9 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -86,7 +86,7 @@ obj-$(CONFIG_FB_CIRRUS)		  += cirrusfb.o
 obj-$(CONFIG_FB_ASILIANT)         += asiliantfb.o
 obj-$(CONFIG_FB_PXA)              += pxafb.o
 obj-$(CONFIG_FB_W100)             += w100fb.o
-obj-$(CONFIG_FB_AU1100)           += au1100fb.o fbgen.o
+obj-$(CONFIG_FB_AU1100)           += au1100fb.o
 obj-$(CONFIG_FB_PMAG_AA)          += pmag-aa-fb.o
 obj-$(CONFIG_FB_PMAG_BA)          += pmag-ba-fb.o
 obj-$(CONFIG_FB_PMAGB_B)          += pmagb-b-fb.o
diff --git a/drivers/video/au1100fb.c b/drivers/video/au1100fb.c
index b6fe30c3ad62..a5129806172f 100644
--- a/drivers/video/au1100fb.c
+++ b/drivers/video/au1100fb.c
@@ -2,6 +2,11 @@
  * BRIEF MODULE DESCRIPTION
  *      Au1100 LCD Driver.
  *
+ * Rewritten for 2.6 by Embedded Alley Solutions
+ *      <source@embeddedalley.com>, based on submissions by
+ *      Karl Lessard <klessard@sunrisetelecom.com>
+ *      <c.pellegrin@exadron.com>
+ *
  * Copyright 2002 MontaVista Software
  * Author: MontaVista Software, Inc.
  *              ppopov@mvista.com or source@mvista.com
@@ -33,298 +38,253 @@
  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  *  675 Mass Ave, Cambridge, MA 02139, USA.
  */
-
+#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/mm.h>
-#include <linux/tty.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/fb.h>
 #include <linux/init.h>
-#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/ctype.h>
+#include <linux/dma-mapping.h>
 
-#include <asm/au1000.h>
-#include <asm/pb1100.h>
-#include "au1100fb.h"
+#include <asm/mach-au1x00/au1000.h>
 
-#include <video/fbcon.h>
-#include <video/fbcon-mfb.h>
-#include <video/fbcon-cfb2.h>
-#include <video/fbcon-cfb4.h>
-#include <video/fbcon-cfb8.h>
-#include <video/fbcon-cfb16.h>
+#define DEBUG 0
+
+#include "au1100fb.h"
 
 /*
  * Sanity check. If this is a new Au1100 based board, search for
  * the PB1100 ifdefs to make sure you modify the code accordingly.
  */
-#if defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100) || defined(CONFIG_MIPS_HYDROGEN3)
+#if defined(CONFIG_MIPS_PB1100)
+  #include <asm/mach-pb1x00/pb1100.h>
+#elif defined(CONFIG_MIPS_DB1100)
+  #include <asm/mach-db1x00/db1x00.h>
 #else
-error Unknown Au1100 board
+  #error "Unknown Au1100 board, Au1100 FB driver not supported"
 #endif
 
-#define CMAPSIZE 16
-
-static int my_lcd_index; /* default is zero */
-struct known_lcd_panels *p_lcd;
-AU1100_LCD *p_lcd_reg = (AU1100_LCD *)AU1100_LCD_ADDR;
-
-struct au1100fb_info {
-        struct fb_info_gen gen;
-        unsigned long fb_virt_start;
-        unsigned long fb_size;
-        unsigned long fb_phys;
-        int mmaped;
-        int nohwcursor;
+#define DRIVER_NAME "au1100fb"
+#define DRIVER_DESC "LCD controller driver for AU1100 processors"
 
-        struct { unsigned red, green, blue, pad; } palette[256];
+#define to_au1100fb_device(_info) \
+          (_info ? container_of(_info, struct au1100fb_device, info) : NULL);
 
-#if defined(FBCON_HAS_CFB16)
-        u16 fbcon_cmap16[16];
-#endif
+/* Bitfields format supported by the controller. Note that the order of formats
+ * SHOULD be the same as in the LCD_CONTROL_SBPPF field, so we can retrieve the
+ * right pixel format by doing rgb_bitfields[LCD_CONTROL_SBPPF_XXX >> LCD_CONTROL_SBPPF]
+ */
+struct fb_bitfield rgb_bitfields[][4] =
+{
+        /*     Red,        Green,        Blue,       Transp   */
+        { { 10, 6, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+        { { 11, 5, 0 }, { 5, 6, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+        { { 11, 5, 0 }, { 6, 5, 0 }, { 0, 6, 0 }, { 0, 0, 0 } },
+        { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 15, 1, 0 } },
+        { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 1, 0 } },
+
+        /* The last is used to describe 12bpp format */
+        { { 8, 4, 0 },  { 4, 4, 0 }, { 0, 4, 0 }, { 0, 0, 0 } },
 };
 
-
-struct au1100fb_par {
-        struct fb_var_screeninfo var;
-
-        int line_length;  // in bytes
-        int cmap_len;     // color-map length
+static struct fb_fix_screeninfo au1100fb_fix __initdata = {
+        .id             = "AU1100 FB",
+        .xpanstep       = 1,
+        .ypanstep       = 1,
+        .type           = FB_TYPE_PACKED_PIXELS,
+        .accel          = FB_ACCEL_NONE,
 };
 
-
-static struct au1100fb_info fb_info;
-static struct au1100fb_par current_par;
-static struct display disp;
-
-int au1100fb_init(void);
-void au1100fb_setup(char *options, int *ints);
-static int au1100fb_mmap(struct fb_info *fb, struct file *file,
-                struct vm_area_struct *vma);
-static int au1100_blank(int blank_mode, struct fb_info_gen *info);
-static int au1100fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                          u_long arg, int con, struct fb_info *info);
-
-void au1100_nocursor(struct display *p, int mode, int xx, int yy){};
-
-static struct fb_ops au1100fb_ops = {
-        .owner          = THIS_MODULE,
-        .fb_get_fix     = fbgen_get_fix,
-        .fb_get_var     = fbgen_get_var,
-        .fb_set_var     = fbgen_set_var,
-        .fb_get_cmap    = fbgen_get_cmap,
-        .fb_set_cmap    = fbgen_set_cmap,
-        .fb_pan_display = fbgen_pan_display,
-        .fb_ioctl       = au1100fb_ioctl,
-        .fb_mmap        = au1100fb_mmap,
+static struct fb_var_screeninfo au1100fb_var __initdata = {
+        .activate       = FB_ACTIVATE_NOW,
+        .height         = -1,
+        .width          = -1,
+        .vmode          = FB_VMODE_NONINTERLACED,
 };
 
-static void au1100_detect(void)
-{
-        /*
-         *  This function should detect the current video mode settings
-         *  and store it as the default video mode
-         */
+static struct au1100fb_drv_info drv_info;
 
-        /*
-         * Yeh, well, we're not going to change any settings so we're
-         * always stuck with the default ...
+/*
+ * Set hardware with var settings. This will enable the controller with a specific
+ * mode, normally validated with the fb_check_var method
          */
-
-}
-
-static int au1100_encode_fix(struct fb_fix_screeninfo *fix,
-                const void *_par, struct fb_info_gen *_info)
+int au1100fb_setmode(struct au1100fb_device *fbdev)
 {
-        struct au1100fb_info *info = (struct au1100fb_info *) _info;
-        struct au1100fb_par *par = (struct au1100fb_par *) _par;
-        struct fb_var_screeninfo *var = &par->var;
-
-        memset(fix, 0, sizeof(struct fb_fix_screeninfo));
-
-        fix->smem_start = info->fb_phys;
-        fix->smem_len = info->fb_size;
-        fix->type = FB_TYPE_PACKED_PIXELS;
-        fix->type_aux = 0;
-        fix->visual = (var->bits_per_pixel == 8) ?
-                FB_VISUAL_PSEUDOCOLOR   : FB_VISUAL_TRUECOLOR;
-        fix->ywrapstep = 0;
-        fix->xpanstep = 1;
-        fix->ypanstep = 1;
-        fix->line_length = current_par.line_length;
-        return 0;
-}
+        struct fb_info *info = &fbdev->info;
+        u32 words;
+        int index;
 
-static void set_color_bitfields(struct fb_var_screeninfo *var)
-{
-        switch (var->bits_per_pixel) {
-        case 8:
-                var->red.offset = 0;
-                var->red.length = 8;
-                var->green.offset = 0;
-                var->green.length = 8;
-                var->blue.offset = 0;
-                var->blue.length = 8;
-                var->transp.offset = 0;
-                var->transp.length = 0;
-                break;
-        case 16:        /* RGB 565 */
-                var->red.offset = 11;
-                var->red.length = 5;
-                var->green.offset = 5;
-                var->green.length = 6;
-                var->blue.offset = 0;
-                var->blue.length = 5;
-                var->transp.offset = 0;
-                var->transp.length = 0;
-                break;
+        if (!fbdev)
+                return -EINVAL;
+
+        /* Update var-dependent FB info */
+        if (panel_is_active(fbdev->panel) || panel_is_color(fbdev->panel)) {
+                if (info->var.bits_per_pixel <= 8) {
+                        /* palettized */
+                        info->var.red.offset    = 0;
+                        info->var.red.length    = info->var.bits_per_pixel;
+                        info->var.red.msb_right = 0;
+
+                        info->var.green.offset  = 0;
+                        info->var.green.length  = info->var.bits_per_pixel;
+                        info->var.green.msb_right = 0;
+
+                        info->var.blue.offset   = 0;
+                        info->var.blue.length   = info->var.bits_per_pixel;
+                        info->var.blue.msb_right = 0;
+
+                        info->var.transp.offset = 0;
+                        info->var.transp.length = 0;
+                        info->var.transp.msb_right = 0;
+
+                        info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                        info->fix.line_length = info->var.xres_virtual /
+                                                        (8/info->var.bits_per_pixel);
+                } else {
+                        /* non-palettized */
+                        index = (fbdev->panel->control_base & LCD_CONTROL_SBPPF_MASK) >> LCD_CONTROL_SBPPF_BIT;
+                        info->var.red = rgb_bitfields[index][0];
+                        info->var.green = rgb_bitfields[index][1];
+                        info->var.blue = rgb_bitfields[index][2];
+                        info->var.transp = rgb_bitfields[index][3];
+
+                        info->fix.visual = FB_VISUAL_TRUECOLOR;
+                        info->fix.line_length = info->var.xres_virtual << 1; /* depth=16 */
+        }
+        } else {
+                /* mono */
+                info->fix.visual = FB_VISUAL_MONO10;
+                info->fix.line_length = info->var.xres_virtual / 8;
         }
 
-        var->red.msb_right = 0;
-        var->green.msb_right = 0;
-        var->blue.msb_right = 0;
-        var->transp.msb_right = 0;
-}
+        info->screen_size = info->fix.line_length * info->var.yres_virtual;
 
-static int au1100_decode_var(const struct fb_var_screeninfo *var,
-                void *_par, struct fb_info_gen *_info)
-{
+        /* Determine BPP mode and format */
+        fbdev->regs->lcd_control = fbdev->panel->control_base |
+                            ((info->var.rotate/90) << LCD_CONTROL_SM_BIT);
 
-        struct au1100fb_par *par = (struct au1100fb_par *)_par;
+        fbdev->regs->lcd_intenable = 0;
+        fbdev->regs->lcd_intstatus = 0;
 
-        /*
-         * Don't allow setting any of these yet: xres and yres don't
-         * make sense for LCD panels.
-         */
-        if (var->xres != p_lcd->xres ||
-            var->yres != p_lcd->yres ||
-            var->xres != p_lcd->xres ||
-            var->yres != p_lcd->yres) {
-                return -EINVAL;
-        }
-        if(var->bits_per_pixel != p_lcd->bpp) {
-                return -EINVAL;
-        }
+        fbdev->regs->lcd_horztiming = fbdev->panel->horztiming;
 
-        memset(par, 0, sizeof(struct au1100fb_par));
-        par->var = *var;
-
-        /* FIXME */
-        switch (var->bits_per_pixel) {
-                case 8:
-                        par->var.bits_per_pixel = 8;
-                        break;
-                case 16:
-                        par->var.bits_per_pixel = 16;
-                        break;
-                default:
-                        printk("color depth %d bpp not supported\n",
-                                        var->bits_per_pixel);
-                        return -EINVAL;
+        fbdev->regs->lcd_verttiming = fbdev->panel->verttiming;
+
+        fbdev->regs->lcd_clkcontrol = fbdev->panel->clkcontrol_base;
 
+        fbdev->regs->lcd_dmaaddr0 = LCD_DMA_SA_N(fbdev->fb_phys);
+
+        if (panel_is_dual(fbdev->panel)) {
+                /* Second panel display seconf half of screen if possible,
+                 * otherwise display the same as the first panel */
+                if (info->var.yres_virtual >= (info->var.yres << 1)) {
+                        fbdev->regs->lcd_dmaaddr1 = LCD_DMA_SA_N(fbdev->fb_phys +
+                                                          (info->fix.line_length *
+                                                          (info->var.yres_virtual >> 1)));
+                } else {
+                        fbdev->regs->lcd_dmaaddr1 = LCD_DMA_SA_N(fbdev->fb_phys);
+                }
         }
-        set_color_bitfields(&par->var);
-        par->cmap_len = (par->var.bits_per_pixel == 8) ? 256 : 16;
-        return 0;
-}
 
-static int au1100_encode_var(struct fb_var_screeninfo *var,
-                const void *par, struct fb_info_gen *_info)
-{
+        words = info->fix.line_length / sizeof(u32);
+        if (!info->var.rotate || (info->var.rotate == 180)) {
+                words *= info->var.yres_virtual;
+                if (info->var.rotate /* 180 */) {
+                        words -= (words % 8); /* should be divisable by 8 */
+                }
+        }
+        fbdev->regs->lcd_words = LCD_WRD_WRDS_N(words);
 
-        *var = ((struct au1100fb_par *)par)->var;
-        return 0;
-}
+        fbdev->regs->lcd_pwmdiv = 0;
+        fbdev->regs->lcd_pwmhi = 0;
 
-static void
-au1100_get_par(void *_par, struct fb_info_gen *_info)
-{
-        *(struct au1100fb_par *)_par = current_par;
-}
+        /* Resume controller */
+        fbdev->regs->lcd_control |= LCD_CONTROL_GO;
 
-static void au1100_set_par(const void *par, struct fb_info_gen *info)
-{
-        /* nothing to do: we don't change any settings */
+        return 0;
 }
 
-static int au1100_getcolreg(unsigned regno, unsigned *red, unsigned *green,
-                         unsigned *blue, unsigned *transp,
-                         struct fb_info *info)
+/* fb_setcolreg
+ * Set color in LCD palette.
+ */
+int au1100fb_fb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *fbi)
 {
+        struct au1100fb_device *fbdev = to_au1100fb_device(fbi);
+        u32 *palette = fbdev->regs->lcd_pallettebase;
+        u32 value;
 
-        struct au1100fb_info* i = (struct au1100fb_info*)info;
-
-        if (regno > 255)
-                return 1;
+        if (regno > (AU1100_LCD_NBR_PALETTE_ENTRIES - 1))
+                return -EINVAL;
 
-        *red    = i->palette[regno].red;
-        *green  = i->palette[regno].green;
-        *blue   = i->palette[regno].blue;
-        *transp = 0;
+        if (fbi->var.grayscale) {
+                /* Convert color to grayscale */
+                red = green = blue =
+                        (19595 * red + 38470 * green + 7471 * blue) >> 16;
+        }
 
-        return 0;
-}
+        if (fbi->fix.visual == FB_VISUAL_TRUECOLOR) {
+                /* Place color in the pseudopalette */
+                if (regno > 16)
+                        return -EINVAL;
 
-static int au1100_setcolreg(unsigned regno, unsigned red, unsigned green,
-                         unsigned blue, unsigned transp,
-                         struct fb_info *info)
-{
-        struct au1100fb_info* i = (struct au1100fb_info *)info;
-        u32 rgbcol;
-
-        if (regno > 255)
-                return 1;
-
-        i->palette[regno].red    = red;
-        i->palette[regno].green  = green;
-        i->palette[regno].blue   = blue;
-
-        switch(p_lcd->bpp) {
-#ifdef FBCON_HAS_CFB8
-        case 8:
-                red >>= 10;
-                green >>= 10;
-                blue >>= 10;
-                p_lcd_reg->lcd_pallettebase[regno] = (blue&0x1f) |
-                        ((green&0x3f)<<5) | ((red&0x1f)<<11);
-                break;
-#endif
-#ifdef FBCON_HAS_CFB16
-        case 16:
-                i->fbcon_cmap16[regno] =
-                        ((red & 0xf800) >> 0) |
-                        ((green & 0xfc00) >> 5) |
-                        ((blue & 0xf800) >> 11);
-                break;
-#endif
-        default:
-                break;
+                palette = (u32*)fbi->pseudo_palette;
+
+                red   >>= (16 - fbi->var.red.length);
+                green >>= (16 - fbi->var.green.length);
+                blue  >>= (16 - fbi->var.blue.length);
+
+                value = (red   << fbi->var.red.offset)  |
+                        (green << fbi->var.green.offset)|
+                        (blue  << fbi->var.blue.offset);
+                value &= 0xFFFF;
+
+        } else if (panel_is_active(fbdev->panel)) {
+                /* COLOR TFT PALLETTIZED (use RGB 565) */
+                value = (red & 0xF800)|((green >> 5) & 0x07E0)|((blue >> 11) & 0x001F);
+                value &= 0xFFFF;
+
+        } else if (panel_is_color(fbdev->panel)) {
+                /* COLOR STN MODE */
+                value = (((panel_swap_rgb(fbdev->panel) ? blue : red) >> 12) & 0x000F) |
+                        ((green >> 8) & 0x00F0) |
+                        (((panel_swap_rgb(fbdev->panel) ? red : blue) >> 4) & 0x0F00);
+                value &= 0xFFF;
+        } else {
+                /* MONOCHROME MODE */
+                value = (green >> 12) & 0x000F;
+                value &= 0xF;
         }
 
+        palette[regno] = value;
+
         return 0;
 }
 
-
-static int  au1100_blank(int blank_mode, struct fb_info_gen *_info)
+/* fb_blank
+ * Blank the screen. Depending on the mode, the screen will be
+ * activated with the backlight color, or desactivated
+ */
+int au1100fb_fb_blank(int blank_mode, struct fb_info *fbi)
 {
+        struct au1100fb_device *fbdev = to_au1100fb_device(fbi);
+
+        print_dbg("fb_blank %d %p", blank_mode, fbi);
 
         switch (blank_mode) {
+
         case VESA_NO_BLANKING:
-                /* turn on panel */
-                //printk("turn on panel\n");
+                        /* Turn on panel */
+                        fbdev->regs->lcd_control |= LCD_CONTROL_GO;
 #ifdef CONFIG_MIPS_PB1100
-                p_lcd_reg->lcd_control |= LCD_CONTROL_GO;
-                au_writew(au_readw(PB1100_G_CONTROL) | p_lcd->mode_backlight,
+                        if (drv_info.panel_idx == 1) {
+                                au_writew(au_readw(PB1100_G_CONTROL)
+                                          | (PB1100_G_CONTROL_BL | PB1100_G_CONTROL_VDD),
                         PB1100_G_CONTROL);
-#endif
-#ifdef CONFIG_MIPS_HYDROGEN3
-                /*  Turn controller & power supply on,  GPIO213 */
-                au_writel(0x20002000, 0xB1700008);
-                au_writel(0x00040000, 0xB1900108);
-                au_writel(0x01000100, 0xB1700008);
+                        }
 #endif
                 au_sync();
                 break;
@@ -332,12 +292,14 @@ static int  au1100_blank(int blank_mode, struct fb_info_gen *_info)
         case VESA_VSYNC_SUSPEND:
         case VESA_HSYNC_SUSPEND:
         case VESA_POWERDOWN:
-                /* turn off panel */
-                //printk("turn off panel\n");
+                        /* Turn off panel */
+                        fbdev->regs->lcd_control &= ~LCD_CONTROL_GO;
 #ifdef CONFIG_MIPS_PB1100
-                au_writew(au_readw(PB1100_G_CONTROL) & ~p_lcd->mode_backlight,
+                        if (drv_info.panel_idx == 1) {
+                                au_writew(au_readw(PB1100_G_CONTROL)
+                                          & ~(PB1100_G_CONTROL_BL | PB1100_G_CONTROL_VDD),
                         PB1100_G_CONTROL);
-                p_lcd_reg->lcd_control &= ~LCD_CONTROL_GO;
+                        }
 #endif
                 au_sync();
                 break;
@@ -348,49 +310,87 @@ static int  au1100_blank(int blank_mode, struct fb_info_gen *_info)
         return 0;
 }
 
-static void au1100_set_disp(const void *unused, struct display *disp,
-                         struct fb_info_gen *info)
+/* fb_pan_display
+ * Pan display in x and/or y as specified
+ */
+int au1100fb_fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
 {
-        disp->screen_base = (char *)fb_info.fb_virt_start;
-
-        switch (disp->var.bits_per_pixel) {
-#ifdef FBCON_HAS_CFB8
-        case 8:
-                disp->dispsw = &fbcon_cfb8;
-                if (fb_info.nohwcursor)
-                        fbcon_cfb8.cursor = au1100_nocursor;
-                break;
-#endif
-#ifdef FBCON_HAS_CFB16
-        case 16:
-                disp->dispsw = &fbcon_cfb16;
-                disp->dispsw_data = fb_info.fbcon_cmap16;
-                if (fb_info.nohwcursor)
-                        fbcon_cfb16.cursor = au1100_nocursor;
-                break;
-#endif
-        default:
-                disp->dispsw = &fbcon_dummy;
-                disp->dispsw_data = NULL;
-                break;
+        struct au1100fb_device *fbdev = to_au1100fb_device(fbi);
+        int dy;
+
+        print_dbg("fb_pan_display %p %p", var, fbi);
+
+        if (!var || !fbdev) {
+                return -EINVAL;
+        }
+
+        if (var->xoffset - fbi->var.xoffset) {
+                /* No support for X panning for now! */
+                return -EINVAL;
+        }
+
+        print_dbg("fb_pan_display 2 %p %p", var, fbi);
+        dy = var->yoffset - fbi->var.yoffset;
+        if (dy) {
+
+                u32 dmaaddr;
+
+                print_dbg("Panning screen of %d lines", dy);
+
+                dmaaddr = fbdev->regs->lcd_dmaaddr0;
+                dmaaddr += (fbi->fix.line_length * dy);
+
+                /* TODO: Wait for current frame to finished */
+                fbdev->regs->lcd_dmaaddr0 = LCD_DMA_SA_N(dmaaddr);
+
+                if (panel_is_dual(fbdev->panel)) {
+                        dmaaddr = fbdev->regs->lcd_dmaaddr1;
+                        dmaaddr += (fbi->fix.line_length * dy);
+                        fbdev->regs->lcd_dmaaddr0 = LCD_DMA_SA_N(dmaaddr);
+        }
+        }
+        print_dbg("fb_pan_display 3 %p %p", var, fbi);
+
+        return 0;
+}
+
+/* fb_rotate
+ * Rotate the display of this angle. This doesn't seems to be used by the core,
+ * but as our hardware supports it, so why not implementing it...
+ */
+void au1100fb_fb_rotate(struct fb_info *fbi, int angle)
+{
+        struct au1100fb_device *fbdev = to_au1100fb_device(fbi);
+
+        print_dbg("fb_rotate %p %d", fbi, angle);
+
+        if (fbdev && (angle > 0) && !(angle % 90)) {
+
+                fbdev->regs->lcd_control &= ~LCD_CONTROL_GO;
+
+                fbdev->regs->lcd_control &= ~(LCD_CONTROL_SM_MASK);
+                fbdev->regs->lcd_control |= ((angle/90) << LCD_CONTROL_SM_BIT);
+
+                fbdev->regs->lcd_control |= LCD_CONTROL_GO;
         }
 }
 
-static int
-au1100fb_mmap(struct fb_info *_fb,
-             struct file *file,
-             struct vm_area_struct *vma)
+/* fb_mmap
+ * Map video memory in user space. We don't use the generic fb_mmap method mainly
+ * to allow the use of the TLB streaming flag (CCA=6)
+ */
+int au1100fb_fb_mmap(struct fb_info *fbi, struct file *file, struct vm_area_struct *vma)
 {
+        struct au1100fb_device *fbdev = to_au1100fb_device(fbi);
         unsigned int len;
         unsigned long start=0, off;
-        struct au1100fb_info *fb = (struct au1100fb_info *)_fb;
 
         if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
                 return -EINVAL;
         }
 
-        start = fb_info.fb_phys & PAGE_MASK;
-        len = PAGE_ALIGN((start & ~PAGE_MASK) + fb_info.fb_size);
+        start = fbdev->fb_phys & PAGE_MASK;
+        len = PAGE_ALIGN((start & ~PAGE_MASK) + fbdev->fb_len);
 
         off = vma->vm_pgoff << PAGE_SHIFT;
 
@@ -401,276 +401,309 @@ au1100fb_mmap(struct fb_info *_fb,
         off += start;
         vma->vm_pgoff = off >> PAGE_SHIFT;
 
-        pgprot_val(vma->vm_page_prot) &= ~_CACHE_MASK;
-        //pgprot_val(vma->vm_page_prot) |= _CACHE_CACHABLE_NONCOHERENT;
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
         pgprot_val(vma->vm_page_prot) |= (6 << 9); //CCA=6
 
-        /* This is an IO map - tell maydump to skip this VMA */
         vma->vm_flags |= VM_IO;
 
-        if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
+        if (io_remap_page_range(vma, vma->vm_start, off,
                                 vma->vm_end - vma->vm_start,
                                 vma->vm_page_prot)) {
                 return -EAGAIN;
         }
 
-        fb->mmaped = 1;
         return 0;
 }
 
-int au1100_pan_display(const struct fb_var_screeninfo *var,
-                       struct fb_info_gen *info)
+static struct fb_ops au1100fb_ops =
 {
-        return 0;
-}
+        .owner                  = THIS_MODULE,
+        .fb_setcolreg           = au1100fb_fb_setcolreg,
+        .fb_blank               = au1100fb_fb_blank,
+        .fb_pan_display         = au1100fb_fb_pan_display,
+        .fb_fillrect            = cfb_fillrect,
+        .fb_copyarea            = cfb_copyarea,
+        .fb_imageblit           = cfb_imageblit,
+        .fb_rotate              = au1100fb_fb_rotate,
+        .fb_mmap                = au1100fb_fb_mmap,
+};
 
-static int au1100fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                          u_long arg, int con, struct fb_info *info)
-{
-        /* nothing to do yet */
-        return -EINVAL;
-}
 
-static struct fbgen_hwswitch au1100_switch = {
-        au1100_detect,
-        au1100_encode_fix,
-        au1100_decode_var,
-        au1100_encode_var,
-        au1100_get_par,
-        au1100_set_par,
-        au1100_getcolreg,
-        au1100_setcolreg,
-        au1100_pan_display,
-        au1100_blank,
-        au1100_set_disp
-};
+/*-------------------------------------------------------------------------*/
 
+/* AU1100 LCD controller device driver */
 
-int au1100_setmode(void)
+int au1100fb_drv_probe(struct device *dev)
 {
-        int words;
-
-        /* FIXME Need to accomodate for swivel mode and 12bpp, <8bpp*/
-        switch (p_lcd->mode_control & LCD_CONTROL_SM)
-        {
-                case LCD_CONTROL_SM_0:
-                case LCD_CONTROL_SM_180:
-                words = (p_lcd->xres * p_lcd->yres * p_lcd->bpp) / 32;
-                        break;
-                case LCD_CONTROL_SM_90:
-                case LCD_CONTROL_SM_270:
-                        /* is this correct? */
-                words = (p_lcd->xres * p_lcd->bpp) / 8;
-                        break;
-                default:
-                        printk("mode_control reg not initialized\n");
+        struct au1100fb_device *fbdev = NULL;
+        struct resource *regs_res;
+        unsigned long page;
+        u32 sys_clksrc;
+
+        if (!dev)
                         return -EINVAL;
+
+        /* Allocate new device private */
+        if (!(fbdev = kmalloc(sizeof(struct au1100fb_device), GFP_KERNEL))) {
+                print_err("fail to allocate device private record");
+                return -ENOMEM;
         }
+        memset((void*)fbdev, 0, sizeof(struct au1100fb_device));
 
-        /*
-         * Setup LCD controller
-         */
+        fbdev->panel = &known_lcd_panels[drv_info.panel_idx];
 
-        p_lcd_reg->lcd_control = p_lcd->mode_control;
-        p_lcd_reg->lcd_intstatus = 0;
-        p_lcd_reg->lcd_intenable = 0;
-        p_lcd_reg->lcd_horztiming = p_lcd->mode_horztiming;
-        p_lcd_reg->lcd_verttiming = p_lcd->mode_verttiming;
-        p_lcd_reg->lcd_clkcontrol = p_lcd->mode_clkcontrol;
-        p_lcd_reg->lcd_words = words - 1;
-        p_lcd_reg->lcd_dmaaddr0 = fb_info.fb_phys;
+        dev_set_drvdata(dev, (void*)fbdev);
 
-        /* turn on panel */
-#ifdef CONFIG_MIPS_PB1100
-        au_writew(au_readw(PB1100_G_CONTROL) | p_lcd->mode_backlight,
-                        PB1100_G_CONTROL);
-#endif
-#ifdef CONFIG_MIPS_HYDROGEN3
-        /*  Turn controller & power supply on,  GPIO213 */
-        au_writel(0x20002000, 0xB1700008);
-        au_writel(0x00040000, 0xB1900108);
-        au_writel(0x01000100, 0xB1700008);
-#endif
+        /* Allocate region for our registers and map them */
+        if (!(regs_res = platform_get_resource(to_platform_device(dev),
+                                        IORESOURCE_MEM, 0))) {
+                print_err("fail to retrieve registers resource");
+                return -EFAULT;
+        }
 
-        p_lcd_reg->lcd_control |= LCD_CONTROL_GO;
+        au1100fb_fix.mmio_start = regs_res->start;
+        au1100fb_fix.mmio_len = regs_res->end - regs_res->start + 1;
 
-        return 0;
-}
+        if (!request_mem_region(au1100fb_fix.mmio_start, au1100fb_fix.mmio_len,
+                                DRIVER_NAME)) {
+                print_err("fail to lock memory region at 0x%08x",
+                                au1100fb_fix.mmio_start);
+                return -EBUSY;
+        }
 
+        fbdev->regs = (struct au1100fb_regs*)KSEG1ADDR(au1100fb_fix.mmio_start);
 
-int __init au1100fb_init(void)
-{
-        uint32 sys_clksrc;
-        unsigned long page;
+        print_dbg("Register memory map at %p", fbdev->regs);
+        print_dbg("phys=0x%08x, size=%d", fbdev->regs_phys, fbdev->regs_len);
 
-        /*
-        * Get the panel information/display mode and update the registry
-        */
-        p_lcd = &panels[my_lcd_index];
-
-        switch (p_lcd->mode_control & LCD_CONTROL_SM)
-        {
-                case LCD_CONTROL_SM_0:
-                case LCD_CONTROL_SM_180:
-                p_lcd->xres =
-                        (p_lcd->mode_horztiming & LCD_HORZTIMING_PPL) + 1;
-                p_lcd->yres =
-                        (p_lcd->mode_verttiming & LCD_VERTTIMING_LPP) + 1;
-                        break;
-                case LCD_CONTROL_SM_90:
-                case LCD_CONTROL_SM_270:
-                p_lcd->yres =
-                        (p_lcd->mode_horztiming & LCD_HORZTIMING_PPL) + 1;
-                p_lcd->xres =
-                        (p_lcd->mode_verttiming & LCD_VERTTIMING_LPP) + 1;
-                        break;
-        }
 
-        /*
-         * Panel dimensions x bpp must be divisible by 32
-         */
-        if (((p_lcd->yres * p_lcd->bpp) % 32) != 0)
-                printk("VERT %% 32\n");
-        if (((p_lcd->xres * p_lcd->bpp) % 32) != 0)
-                printk("HORZ %% 32\n");
 
-        /*
-         * Allocate LCD framebuffer from system memory
-         */
-        fb_info.fb_size = (p_lcd->xres * p_lcd->yres * p_lcd->bpp) / 8;
-
-        current_par.var.xres = p_lcd->xres;
-        current_par.var.xres_virtual = p_lcd->xres;
-        current_par.var.yres = p_lcd->yres;
-        current_par.var.yres_virtual = p_lcd->yres;
-        current_par.var.bits_per_pixel = p_lcd->bpp;
-
-        /* FIX!!! only works for 8/16 bpp */
-        current_par.line_length = p_lcd->xres * p_lcd->bpp / 8; /* in bytes */
-        fb_info.fb_virt_start = (unsigned long )
-                __get_free_pages(GFP_ATOMIC | GFP_DMA,
-                                get_order(fb_info.fb_size + 0x1000));
-        if (!fb_info.fb_virt_start) {
-                printk("Unable to allocate fb memory\n");
+        /* Allocate the framebuffer to the maximum screen size * nbr of video buffers */
+        fbdev->fb_len = fbdev->panel->xres * fbdev->panel->yres *
+                        (fbdev->panel->bpp >> 3) * AU1100FB_NBR_VIDEO_BUFFERS;
+
+        fbdev->fb_mem = dma_alloc_coherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                        &fbdev->fb_phys, GFP_KERNEL);
+        if (!fbdev->fb_mem) {
+                print_err("fail to allocate frambuffer (size: %dK))",
+                          fbdev->fb_len / 1024);
                 return -ENOMEM;
         }
-        fb_info.fb_phys = virt_to_bus((void *)fb_info.fb_virt_start);
+
+        au1100fb_fix.smem_start = fbdev->fb_phys;
+        au1100fb_fix.smem_len = fbdev->fb_len;
 
         /*
          * Set page reserved so that mmap will work. This is necessary
          * since we'll be remapping normal memory.
          */
-        for (page = fb_info.fb_virt_start;
-             page < PAGE_ALIGN(fb_info.fb_virt_start + fb_info.fb_size);
+        for (page = (unsigned long)fbdev->fb_mem;
+             page < PAGE_ALIGN((unsigned long)fbdev->fb_mem + fbdev->fb_len);
              page += PAGE_SIZE) {
+#if CONFIG_DMA_NONCOHERENT
+                SetPageReserved(virt_to_page(CAC_ADDR(page)));
+#else
                 SetPageReserved(virt_to_page(page));
+#endif
         }
 
-        memset((void *)fb_info.fb_virt_start, 0, fb_info.fb_size);
-
-        /* set freqctrl now to allow more time to stabilize */
-        /* zero-out out LCD bits */
-        sys_clksrc = au_readl(SYS_CLKSRC) & ~0x000003e0;
-        sys_clksrc |= p_lcd->mode_toyclksrc;
-        au_writel(sys_clksrc, SYS_CLKSRC);
-
-        /* FIXME add check to make sure auxpll is what is expected! */
-        au1100_setmode();
-
-        fb_info.gen.parsize = sizeof(struct au1100fb_par);
-        fb_info.gen.fbhw = &au1100_switch;
-
-        strcpy(fb_info.gen.info.modename, "Au1100 LCD");
-        fb_info.gen.info.changevar = NULL;
-        fb_info.gen.info.node = -1;
-
-        fb_info.gen.info.fbops = &au1100fb_ops;
-        fb_info.gen.info.disp = &disp;
-        fb_info.gen.info.switch_con = &fbgen_switch;
-        fb_info.gen.info.updatevar = &fbgen_update_var;
-        fb_info.gen.info.blank = &fbgen_blank;
-        fb_info.gen.info.flags = FBINFO_FLAG_DEFAULT;
-
-        /* This should give a reasonable default video mode */
-        fbgen_get_var(&disp.var, -1, &fb_info.gen.info);
-        fbgen_do_set_var(&disp.var, 1, &fb_info.gen);
-        fbgen_set_disp(-1, &fb_info.gen);
-        fbgen_install_cmap(0, &fb_info.gen);
-        if (register_framebuffer(&fb_info.gen.info) < 0)
-                return -EINVAL;
-        printk(KERN_INFO "fb%d: %s frame buffer device\n",
-                        GET_FB_IDX(fb_info.gen.info.node),
-                        fb_info.gen.info.modename);
+        print_dbg("Framebuffer memory map at %p", fbdev->fb_mem);
+        print_dbg("phys=0x%08x, size=%dK", fbdev->fb_phys, fbdev->fb_len / 1024);
+
+        /* Setup LCD clock to AUX (48 MHz) */
+        sys_clksrc = au_readl(SYS_CLKSRC) & ~(SYS_CS_ML_MASK | SYS_CS_DL | SYS_CS_CL);
+        au_writel((sys_clksrc | (1 << SYS_CS_ML_BIT)), SYS_CLKSRC);
+
+        /* load the panel info into the var struct */
+        au1100fb_var.bits_per_pixel = fbdev->panel->bpp;
+        au1100fb_var.xres = fbdev->panel->xres;
+        au1100fb_var.xres_virtual = au1100fb_var.xres;
+        au1100fb_var.yres = fbdev->panel->yres;
+        au1100fb_var.yres_virtual = au1100fb_var.yres;
+
+        fbdev->info.screen_base = fbdev->fb_mem;
+        fbdev->info.fbops = &au1100fb_ops;
+        fbdev->info.fix = au1100fb_fix;
+
+        if (!(fbdev->info.pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL))) {
+                return -ENOMEM;
+        }
+        memset(fbdev->info.pseudo_palette, 0, sizeof(u32) * 16);
+
+        if (fb_alloc_cmap(&fbdev->info.cmap, AU1100_LCD_NBR_PALETTE_ENTRIES, 0) < 0) {
+                print_err("Fail to allocate colormap (%d entries)",
+                           AU1100_LCD_NBR_PALETTE_ENTRIES);
+                kfree(fbdev->info.pseudo_palette);
+                return -EFAULT;
+        }
+
+        fbdev->info.var = au1100fb_var;
+
+        /* Set h/w registers */
+        au1100fb_setmode(fbdev);
+
+        /* Register new framebuffer */
+        if (register_framebuffer(&fbdev->info) < 0) {
+                print_err("cannot register new framebuffer");
+                goto failed;
+        }
+
+        return 0;
+
+failed:
+        if (fbdev->regs) {
+                release_mem_region(fbdev->regs_phys, fbdev->regs_len);
+        }
+        if (fbdev->fb_mem) {
+                dma_free_noncoherent(dev, fbdev->fb_len, fbdev->fb_mem, fbdev->fb_phys);
+        }
+        if (fbdev->info.cmap.len != 0) {
+                fb_dealloc_cmap(&fbdev->info.cmap);
+        }
+        kfree(fbdev);
+        dev_set_drvdata(dev, NULL);
 
         return 0;
 }
 
+int au1100fb_drv_remove(struct device *dev)
+{
+        struct au1100fb_device *fbdev = NULL;
+
+        if (!dev)
+                return -ENODEV;
+
+        fbdev = (struct au1100fb_device*) dev_get_drvdata(dev);
+
+#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
+        au1100fb_fb_blank(VESA_POWERDOWN, &fbdev->info);
+#endif
+        fbdev->regs->lcd_control &= ~LCD_CONTROL_GO;
 
-void au1100fb_cleanup(struct fb_info *info)
+        /* Clean up all probe data */
+        unregister_framebuffer(&fbdev->info);
+
+        release_mem_region(fbdev->regs_phys, fbdev->regs_len);
+
+        dma_free_coherent(dev, PAGE_ALIGN(fbdev->fb_len), fbdev->fb_mem, fbdev->fb_phys);
+
+        fb_dealloc_cmap(&fbdev->info.cmap);
+        kfree(fbdev->info.pseudo_palette);
+        kfree((void*)fbdev);
+
+        return 0;
+}
+
+int au1100fb_drv_suspend(struct device *dev, u32 state, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+
+int au1100fb_drv_resume(struct device *dev, u32 level)
 {
-        unregister_framebuffer(info);
+        /* TODO */
+        return 0;
 }
 
+static struct device_driver au1100fb_driver = {
+        .name           = "au1100-lcd",
+        .bus            = &platform_bus_type,
 
-void au1100fb_setup(char *options, int *ints)
+        .probe          = au1100fb_drv_probe,
+        .remove         = au1100fb_drv_remove,
+        .suspend        = au1100fb_drv_suspend,
+        .resume         = au1100fb_drv_resume,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Kernel driver */
+
+int au1100fb_setup(char *options)
 {
         char* this_opt;
-        int i;
-        int num_panels = sizeof(panels)/sizeof(struct known_lcd_panels);
+        int num_panels = ARRAY_SIZE(known_lcd_panels);
+        char* mode = NULL;
+        int panel_idx = 0;
 
+        if (num_panels <= 0) {
+                print_err("No LCD panels supported by driver!");
+                return -EFAULT;
+                        }
 
-        if (!options || !*options)
-                return;
-
-        for(this_opt=strtok(options, ","); this_opt;
-            this_opt=strtok(NULL, ",")) {
+        if (options) {
+                while ((this_opt = strsep(&options,",")) != NULL) {
+                        /* Panel option */
                 if (!strncmp(this_opt, "panel:", 6)) {
-#if defined(CONFIG_MIPS_PB1100) || defined(CONFIG_MIPS_DB1100)
-                        /* Read Pb1100 Switch S10 ? */
-                        if (!strncmp(this_opt+6, "s10", 3))
-                        {
-                                int panel;
-                                panel = *(volatile int *)0xAE000008; /* BCSR SWITCHES */
-                                panel >>= 8;
-                                panel &= 0x0F;
-                                if (panel >= num_panels) panel = 0;
-                                my_lcd_index = panel;
-                        }
-                        else
-#endif
-                        /* Get the panel name, everything else if fixed */
-                        for (i=0; i<num_panels; i++) {
-                                if (!strncmp(this_opt+6, panels[i].panel_name,
+                                int i;
+                                this_opt += 6;
+                                for (i = 0; i < num_panels; i++) {
+                                        if (!strncmp(this_opt,
+                                                     known_lcd_panels[i].name,
                                                         strlen(this_opt))) {
-                                        my_lcd_index = i;
+                                                panel_idx = i;
                                         break;
                                 }
                         }
+                                if (i >= num_panels) {
+                                        print_warn("Panel %s not supported!", this_opt);
+                                }
+                        }
+                        /* Mode option (only option that start with digit) */
+                        else if (isdigit(this_opt[0])) {
+                                mode = kmalloc(strlen(this_opt) + 1, GFP_KERNEL);
+                                strncpy(mode, this_opt, strlen(this_opt) + 1);
+                        }
+                        /* Unsupported option */
+                        else {
+                                print_warn("Unsupported option \"%s\"", this_opt);
                 }
-                else if (!strncmp(this_opt, "nohwcursor", 10)) {
-                        printk("nohwcursor\n");
-                        fb_info.nohwcursor = 1;
                 }
         }
 
-        printk("au1100fb: Panel %d %s\n", my_lcd_index,
-                panels[my_lcd_index].panel_name);
-}
+        drv_info.panel_idx = panel_idx;
+        drv_info.opt_mode = mode;
 
+        print_info("Panel=%s Mode=%s",
+                        known_lcd_panels[drv_info.panel_idx].name,
+                        drv_info.opt_mode ? drv_info.opt_mode : "default");
 
+        return 0;
+}
 
-#ifdef MODULE
-MODULE_LICENSE("GPL");
-int init_module(void)
+int __init au1100fb_init(void)
 {
-        return au1100fb_init();
+        char* options;
+        int ret;
+
+        print_info("" DRIVER_DESC "");
+
+        memset(&drv_info, 0, sizeof(drv_info));
+
+        if (fb_get_options(DRIVER_NAME, &options))
+                return -ENODEV;
+
+        /* Setup driver with options */
+        ret = au1100fb_setup(options);
+        if (ret < 0) {
+                print_err("Fail to setup driver");
+                return ret;
+        }
+
+        return driver_register(&au1100fb_driver);
 }
 
-void cleanup_module(void)
+void __exit au1100fb_cleanup(void)
 {
-        au1100fb_cleanup(void);
+        driver_unregister(&au1100fb_driver);
+
+        if (drv_info.opt_mode)
+                kfree(drv_info.opt_mode);
 }
 
-MODULE_AUTHOR("Pete Popov <ppopov@mvista.com>");
-MODULE_DESCRIPTION("Au1100 LCD framebuffer device driver");
-#endif /* MODULE */
+module_init(au1100fb_init);
+module_exit(au1100fb_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/au1100fb.h b/drivers/video/au1100fb.h
index 657c560ab73c..2855534dc235 100644
--- a/drivers/video/au1100fb.h
+++ b/drivers/video/au1100fb.h
@@ -30,352 +30,352 @@
 #ifndef _AU1100LCD_H
 #define _AU1100LCD_H
 
+#include <asm/mach-au1x00/au1000.h>
+
+#define print_err(f, arg...) printk(KERN_ERR DRIVER_NAME ": " f "\n", ## arg)
+#define print_warn(f, arg...) printk(KERN_WARNING DRIVER_NAME ": " f "\n", ## arg)
+#define print_info(f, arg...) printk(KERN_INFO DRIVER_NAME ": " f "\n", ## arg)
+
+#if DEBUG
+#define print_dbg(f, arg...) printk(__FILE__ ": " f "\n", ## arg)
+#else
+#define print_dbg(f, arg...) do {} while (0)
+#endif
+
+#if defined(__BIG_ENDIAN)
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_11
+#else
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_00
+#endif
+#define LCD_CONTROL_DEFAULT_SBPPF LCD_CONTROL_SBPPF_565
+
 /********************************************************************/
-#define uint32 unsigned long
-typedef volatile struct
-{
-        uint32  lcd_control;
-        uint32  lcd_intstatus;
-        uint32  lcd_intenable;
-        uint32  lcd_horztiming;
-        uint32  lcd_verttiming;
-        uint32  lcd_clkcontrol;
-        uint32  lcd_dmaaddr0;
-        uint32  lcd_dmaaddr1;
-        uint32  lcd_words;
-        uint32  lcd_pwmdiv;
-        uint32  lcd_pwmhi;
-        uint32  reserved[(0x0400-0x002C)/4];
-        uint32  lcd_pallettebase[256];
-
-} AU1100_LCD;
+
+/* LCD controller restrictions */
+#define AU1100_LCD_MAX_XRES     800
+#define AU1100_LCD_MAX_YRES     600
+#define AU1100_LCD_MAX_BPP      16
+#define AU1100_LCD_MAX_CLK      48000000
+#define AU1100_LCD_NBR_PALETTE_ENTRIES 256
+
+/* Default number of visible screen buffer to allocate */
+#define AU1100FB_NBR_VIDEO_BUFFERS 4
 
 /********************************************************************/
 
-#define AU1100_LCD_ADDR         0xB5000000
+struct au1100fb_panel
+{
+        const char name[25];            /* Full name <vendor>_<model> */
 
-/*
- * Register bit definitions
- */
+        u32     control_base;           /* Mode-independent control values */
+        u32     clkcontrol_base;        /* Panel pixclock preferences */
 
-/* lcd_control */
-#define LCD_CONTROL_SBPPF               (7<<18)
-#define LCD_CONTROL_SBPPF_655   (0<<18)
-#define LCD_CONTROL_SBPPF_565   (1<<18)
-#define LCD_CONTROL_SBPPF_556   (2<<18)
-#define LCD_CONTROL_SBPPF_1555  (3<<18)
-#define LCD_CONTROL_SBPPF_5551  (4<<18)
-#define LCD_CONTROL_WP                  (1<<17)
-#define LCD_CONTROL_WD                  (1<<16)
-#define LCD_CONTROL_C                   (1<<15)
-#define LCD_CONTROL_SM                  (3<<13)
-#define LCD_CONTROL_SM_0                (0<<13)
-#define LCD_CONTROL_SM_90               (1<<13)
-#define LCD_CONTROL_SM_180              (2<<13)
-#define LCD_CONTROL_SM_270              (3<<13)
-#define LCD_CONTROL_DB                  (1<<12)
-#define LCD_CONTROL_CCO                 (1<<11)
-#define LCD_CONTROL_DP                  (1<<10)
-#define LCD_CONTROL_PO                  (3<<8)
-#define LCD_CONTROL_PO_00               (0<<8)
-#define LCD_CONTROL_PO_01               (1<<8)
-#define LCD_CONTROL_PO_10               (2<<8)
-#define LCD_CONTROL_PO_11               (3<<8)
-#define LCD_CONTROL_MPI                 (1<<7)
-#define LCD_CONTROL_PT                  (1<<6)
-#define LCD_CONTROL_PC                  (1<<5)
-#define LCD_CONTROL_BPP                 (7<<1)
-#define LCD_CONTROL_BPP_1               (0<<1)
-#define LCD_CONTROL_BPP_2               (1<<1)
-#define LCD_CONTROL_BPP_4               (2<<1)
-#define LCD_CONTROL_BPP_8               (3<<1)
-#define LCD_CONTROL_BPP_12              (4<<1)
-#define LCD_CONTROL_BPP_16              (5<<1)
-#define LCD_CONTROL_GO                  (1<<0)
-
-/* lcd_intstatus, lcd_intenable */
-#define LCD_INT_SD                              (1<<7)
-#define LCD_INT_OF                              (1<<6)
-#define LCD_INT_UF                              (1<<5)
-#define LCD_INT_SA                              (1<<3)
-#define LCD_INT_SS                              (1<<2)
-#define LCD_INT_S1                              (1<<1)
-#define LCD_INT_S0                              (1<<0)
-
-/* lcd_horztiming */
-#define LCD_HORZTIMING_HN2              (255<<24)
-#define LCD_HORZTIMING_HN2_N(N) (((N)-1)<<24)
-#define LCD_HORZTIMING_HN1              (255<<16)
-#define LCD_HORZTIMING_HN1_N(N) (((N)-1)<<16)
-#define LCD_HORZTIMING_HPW              (63<<10)
-#define LCD_HORZTIMING_HPW_N(N) (((N)-1)<<10)
-#define LCD_HORZTIMING_PPL              (1023<<0)
-#define LCD_HORZTIMING_PPL_N(N) (((N)-1)<<0)
-
-/* lcd_verttiming */
-#define LCD_VERTTIMING_VN2              (255<<24)
-#define LCD_VERTTIMING_VN2_N(N) (((N)-1)<<24)
-#define LCD_VERTTIMING_VN1              (255<<16)
-#define LCD_VERTTIMING_VN1_N(N) (((N)-1)<<16)
-#define LCD_VERTTIMING_VPW              (63<<10)
-#define LCD_VERTTIMING_VPW_N(N) (((N)-1)<<10)
-#define LCD_VERTTIMING_LPP              (1023<<0)
-#define LCD_VERTTIMING_LPP_N(N) (((N)-1)<<0)
-
-/* lcd_clkcontrol */
-#define LCD_CLKCONTROL_IB               (1<<18)
-#define LCD_CLKCONTROL_IC               (1<<17)
-#define LCD_CLKCONTROL_IH               (1<<16)
-#define LCD_CLKCONTROL_IV               (1<<15)
-#define LCD_CLKCONTROL_BF               (31<<10)
-#define LCD_CLKCONTROL_BF_N(N)  (((N)-1)<<10)
-#define LCD_CLKCONTROL_PCD              (1023<<0)
-#define LCD_CLKCONTROL_PCD_N(N) ((N)<<0)
-
-/* lcd_pwmdiv */
-#define LCD_PWMDIV_EN                   (1<<12)
-#define LCD_PWMDIV_PWMDIV               (2047<<0)
-#define LCD_PWMDIV_PWMDIV_N(N)  (((N)-1)<<0)
-
-/* lcd_pwmhi */
-#define LCD_PWMHI_PWMHI1                (2047<<12)
-#define LCD_PWMHI_PWMHI1_N(N)   ((N)<<12)
-#define LCD_PWMHI_PWMHI0                (2047<<0)
-#define LCD_PWMHI_PWMHI0_N(N)   ((N)<<0)
-
-/* lcd_pallettebase - MONOCHROME */
-#define LCD_PALLETTE_MONO_MI            (15<<0)
-#define LCD_PALLETTE_MONO_MI_N(N)       ((N)<<0)
-
-/* lcd_pallettebase - COLOR */
-#define LCD_PALLETTE_COLOR_BI           (15<<8)
-#define LCD_PALLETTE_COLOR_BI_N(N)      ((N)<<8)
-#define LCD_PALLETTE_COLOR_GI           (15<<4)
-#define LCD_PALLETTE_COLOR_GI_N(N)      ((N)<<4)
-#define LCD_PALLETTE_COLOR_RI           (15<<0)
-#define LCD_PALLETTE_COLOR_RI_N(N)      ((N)<<0)
-
-/* lcd_palletebase - COLOR TFT PALLETIZED */
-#define LCD_PALLETTE_TFT_DC                     (65535<<0)
-#define LCD_PALLETTE_TFT_DC_N(N)        ((N)<<0)
+        u32     horztiming;
+        u32     verttiming;
 
-/********************************************************************/
+        u32     xres;           /* Maximum horizontal resolution */
+        u32     yres;           /* Maximum vertical resolution */
+        u32     bpp;            /* Maximum depth supported */
+};
 
-struct known_lcd_panels
+struct au1100fb_regs
 {
-        uint32 xres;
-        uint32 yres;
-        uint32 bpp;
-        unsigned char  panel_name[256];
-        uint32 mode_control;
-        uint32 mode_horztiming;
-        uint32 mode_verttiming;
-        uint32 mode_clkcontrol;
-        uint32 mode_pwmdiv;
-        uint32 mode_pwmhi;
-        uint32 mode_toyclksrc;
-        uint32 mode_backlight;
+        u32  lcd_control;
+        u32  lcd_intstatus;
+        u32  lcd_intenable;
+        u32  lcd_horztiming;
+        u32  lcd_verttiming;
+        u32  lcd_clkcontrol;
+        u32  lcd_dmaaddr0;
+        u32  lcd_dmaaddr1;
+        u32  lcd_words;
+        u32  lcd_pwmdiv;
+        u32  lcd_pwmhi;
+        u32  reserved[(0x0400-0x002C)/4];
+        u32  lcd_pallettebase[256];
+};
+
+struct au1100fb_device {
+
+        struct fb_info info;                    /* FB driver info record */
 
+        struct au1100fb_panel   *panel;         /* Panel connected to this device */
+
+        struct au1100fb_regs*   regs;           /* Registers memory map */
+        size_t                  regs_len;
+        unsigned int            regs_phys;
+
+        unsigned char*          fb_mem;         /* FrameBuffer memory map */
+        size_t                  fb_len;
+        dma_addr_t              fb_phys;
 };
 
-#if defined(__BIG_ENDIAN)
-#define LCD_DEFAULT_PIX_FORMAT LCD_CONTROL_PO_11
-#else
-#define LCD_DEFAULT_PIX_FORMAT LCD_CONTROL_PO_00
-#endif
+/********************************************************************/
 
-/*
- * The fb driver assumes that AUX PLL is at 48MHz.  That can
- * cover up to 800x600 resolution; if you need higher resolution,
- * you should modify the driver as needed, not just this structure.
+#define LCD_CONTROL                (AU1100_LCD_BASE + 0x0)
+  #define LCD_CONTROL_SBB_BIT      21
+  #define LCD_CONTROL_SBB_MASK     (0x3 << LCD_CONTROL_SBB_BIT)
+    #define LCD_CONTROL_SBB_1        (0 << LCD_CONTROL_SBB_BIT)
+    #define LCD_CONTROL_SBB_2        (1 << LCD_CONTROL_SBB_BIT)
+    #define LCD_CONTROL_SBB_3        (2 << LCD_CONTROL_SBB_BIT)
+    #define LCD_CONTROL_SBB_4        (3 << LCD_CONTROL_SBB_BIT)
+  #define LCD_CONTROL_SBPPF_BIT    18
+  #define LCD_CONTROL_SBPPF_MASK   (0x7 << LCD_CONTROL_SBPPF_BIT)
+    #define LCD_CONTROL_SBPPF_655    (0 << LCD_CONTROL_SBPPF_BIT)
+    #define LCD_CONTROL_SBPPF_565    (1 << LCD_CONTROL_SBPPF_BIT)
+    #define LCD_CONTROL_SBPPF_556    (2 << LCD_CONTROL_SBPPF_BIT)
+    #define LCD_CONTROL_SBPPF_1555   (3 << LCD_CONTROL_SBPPF_BIT)
+    #define LCD_CONTROL_SBPPF_5551   (4 << LCD_CONTROL_SBPPF_BIT)
+  #define LCD_CONTROL_WP           (1<<17)
+  #define LCD_CONTROL_WD           (1<<16)
+  #define LCD_CONTROL_C            (1<<15)
+  #define LCD_CONTROL_SM_BIT       13
+  #define LCD_CONTROL_SM_MASK      (0x3 << LCD_CONTROL_SM_BIT)
+    #define LCD_CONTROL_SM_0         (0 << LCD_CONTROL_SM_BIT)
+    #define LCD_CONTROL_SM_90        (1 << LCD_CONTROL_SM_BIT)
+    #define LCD_CONTROL_SM_180       (2 << LCD_CONTROL_SM_BIT)
+    #define LCD_CONTROL_SM_270       (3 << LCD_CONTROL_SM_BIT)
+  #define LCD_CONTROL_DB           (1<<12)
+  #define LCD_CONTROL_CCO          (1<<11)
+  #define LCD_CONTROL_DP           (1<<10)
+  #define LCD_CONTROL_PO_BIT       8
+  #define LCD_CONTROL_PO_MASK      (0x3 << LCD_CONTROL_PO_BIT)
+    #define LCD_CONTROL_PO_00        (0 << LCD_CONTROL_PO_BIT)
+    #define LCD_CONTROL_PO_01        (1 << LCD_CONTROL_PO_BIT)
+    #define LCD_CONTROL_PO_10        (2 << LCD_CONTROL_PO_BIT)
+    #define LCD_CONTROL_PO_11        (3 << LCD_CONTROL_PO_BIT)
+  #define LCD_CONTROL_MPI          (1<<7)
+  #define LCD_CONTROL_PT           (1<<6)
+  #define LCD_CONTROL_PC           (1<<5)
+  #define LCD_CONTROL_BPP_BIT      1
+  #define LCD_CONTROL_BPP_MASK     (0x7 << LCD_CONTROL_BPP_BIT)
+    #define LCD_CONTROL_BPP_1        (0 << LCD_CONTROL_BPP_BIT)
+    #define LCD_CONTROL_BPP_2        (1 << LCD_CONTROL_BPP_BIT)
+    #define LCD_CONTROL_BPP_4        (2 << LCD_CONTROL_BPP_BIT)
+    #define LCD_CONTROL_BPP_8        (3 << LCD_CONTROL_BPP_BIT)
+    #define LCD_CONTROL_BPP_12       (4 << LCD_CONTROL_BPP_BIT)
+    #define LCD_CONTROL_BPP_16       (5 << LCD_CONTROL_BPP_BIT)
+  #define LCD_CONTROL_GO           (1<<0)
+
+#define LCD_INTSTATUS              (AU1100_LCD_BASE + 0x4)
+#define LCD_INTENABLE              (AU1100_LCD_BASE + 0x8)
+  #define LCD_INT_SD               (1<<7)
+  #define LCD_INT_OF               (1<<6)
+  #define LCD_INT_UF               (1<<5)
+  #define LCD_INT_SA               (1<<3)
+  #define LCD_INT_SS               (1<<2)
+  #define LCD_INT_S1               (1<<1)
+  #define LCD_INT_S0               (1<<0)
+
+#define LCD_HORZTIMING             (AU1100_LCD_BASE + 0xC)
+  #define LCD_HORZTIMING_HN2_BIT   24
+  #define LCD_HORZTIMING_HN2_MASK  (0xFF << LCD_HORZTIMING_HN2_BIT)
+  #define LCD_HORZTIMING_HN2_N(N)  ((((N)-1) << LCD_HORZTIMING_HN2_BIT) & LCD_HORZTIMING_HN2_MASK)
+  #define LCD_HORZTIMING_HN1_BIT   16
+  #define LCD_HORZTIMING_HN1_MASK  (0xFF << LCD_HORZTIMING_HN1_BIT)
+  #define LCD_HORZTIMING_HN1_N(N)  ((((N)-1) << LCD_HORZTIMING_HN1_BIT) & LCD_HORZTIMING_HN1_MASK)
+  #define LCD_HORZTIMING_HPW_BIT   10
+  #define LCD_HORZTIMING_HPW_MASK  (0x3F << LCD_HORZTIMING_HPW_BIT)
+  #define LCD_HORZTIMING_HPW_N(N)  ((((N)-1) << LCD_HORZTIMING_HPW_BIT) & LCD_HORZTIMING_HPW_MASK)
+  #define LCD_HORZTIMING_PPL_BIT   0
+  #define LCD_HORZTIMING_PPL_MASK  (0x3FF << LCD_HORZTIMING_PPL_BIT)
+  #define LCD_HORZTIMING_PPL_N(N)  ((((N)-1) << LCD_HORZTIMING_PPL_BIT) & LCD_HORZTIMING_PPL_MASK)
+
+#define LCD_VERTTIMING             (AU1100_LCD_BASE + 0x10)
+  #define LCD_VERTTIMING_VN2_BIT   24
+  #define LCD_VERTTIMING_VN2_MASK  (0xFF << LCD_VERTTIMING_VN2_BIT)
+  #define LCD_VERTTIMING_VN2_N(N)  ((((N)-1) << LCD_VERTTIMING_VN2_BIT) & LCD_VERTTIMING_VN2_MASK)
+  #define LCD_VERTTIMING_VN1_BIT   16
+  #define LCD_VERTTIMING_VN1_MASK  (0xFF << LCD_VERTTIMING_VN1_BIT)
+  #define LCD_VERTTIMING_VN1_N(N)  ((((N)-1) << LCD_VERTTIMING_VN1_BIT) & LCD_VERTTIMING_VN1_MASK)
+  #define LCD_VERTTIMING_VPW_BIT   10
+  #define LCD_VERTTIMING_VPW_MASK  (0x3F << LCD_VERTTIMING_VPW_BIT)
+  #define LCD_VERTTIMING_VPW_N(N)  ((((N)-1) << LCD_VERTTIMING_VPW_BIT) & LCD_VERTTIMING_VPW_MASK)
+  #define LCD_VERTTIMING_LPP_BIT   0
+  #define LCD_VERTTIMING_LPP_MASK  (0x3FF << LCD_VERTTIMING_LPP_BIT)
+  #define LCD_VERTTIMING_LPP_N(N)  ((((N)-1) << LCD_VERTTIMING_LPP_BIT) & LCD_VERTTIMING_LPP_MASK)
+
+#define LCD_CLKCONTROL             (AU1100_LCD_BASE + 0x14)
+  #define LCD_CLKCONTROL_IB        (1<<18)
+  #define LCD_CLKCONTROL_IC        (1<<17)
+  #define LCD_CLKCONTROL_IH        (1<<16)
+  #define LCD_CLKCONTROL_IV        (1<<15)
+  #define LCD_CLKCONTROL_BF_BIT    10
+  #define LCD_CLKCONTROL_BF_MASK   (0x1F << LCD_CLKCONTROL_BF_BIT)
+  #define LCD_CLKCONTROL_BF_N(N)   ((((N)-1) << LCD_CLKCONTROL_BF_BIT) & LCD_CLKCONTROL_BF_MASK)
+  #define LCD_CLKCONTROL_PCD_BIT   0
+  #define LCD_CLKCONTROL_PCD_MASK  (0x3FF << LCD_CLKCONTROL_PCD_BIT)
+  #define LCD_CLKCONTROL_PCD_N(N)  (((N) << LCD_CLKCONTROL_PCD_BIT) & LCD_CLKCONTROL_PCD_MASK)
+
+#define LCD_DMAADDR0               (AU1100_LCD_BASE + 0x18)
+#define LCD_DMAADDR1               (AU1100_LCD_BASE + 0x1C)
+  #define LCD_DMA_SA_BIT           5
+  #define LCD_DMA_SA_MASK          (0x7FFFFFF << LCD_DMA_SA_BIT)
+  #define LCD_DMA_SA_N(N)          ((N) & LCD_DMA_SA_MASK)
+
+#define LCD_WORDS                  (AU1100_LCD_BASE + 0x20)
+  #define LCD_WRD_WRDS_BIT         0
+  #define LCD_WRD_WRDS_MASK        (0xFFFFFFFF << LCD_WRD_WRDS_BIT)
+  #define LCD_WRD_WRDS_N(N)        ((((N)-1) << LCD_WRD_WRDS_BIT) & LCD_WRD_WRDS_MASK)
+
+#define LCD_PWMDIV                 (AU1100_LCD_BASE + 0x24)
+  #define LCD_PWMDIV_EN            (1<<12)
+  #define LCD_PWMDIV_PWMDIV_BIT    0
+  #define LCD_PWMDIV_PWMDIV_MASK   (0xFFF << LCD_PWMDIV_PWMDIV_BIT)
+  #define LCD_PWMDIV_PWMDIV_N(N)   ((((N)-1) << LCD_PWMDIV_PWMDIV_BIT) & LCD_PWMDIV_PWMDIV_MASK)
+
+#define LCD_PWMHI                  (AU1100_LCD_BASE + 0x28)
+  #define LCD_PWMHI_PWMHI1_BIT     12
+  #define LCD_PWMHI_PWMHI1_MASK    (0xFFF << LCD_PWMHI_PWMHI1_BIT)
+  #define LCD_PWMHI_PWMHI1_N(N)    (((N) << LCD_PWMHI_PWMHI1_BIT) & LCD_PWMHI_PWMHI1_MASK)
+  #define LCD_PWMHI_PWMHI0_BIT     0
+  #define LCD_PWMHI_PWMHI0_MASK    (0xFFF << LCD_PWMHI_PWMHI0_BIT)
+  #define LCD_PWMHI_PWMHI0_N(N)    (((N) << LCD_PWMHI_PWMHI0_BIT) & LCD_PWMHI_PWMHI0_MASK)
+
+#define LCD_PALLETTEBASE                (AU1100_LCD_BASE + 0x400)
+  #define LCD_PALLETTE_MONO_MI_BIT      0
+  #define LCD_PALLETTE_MONO_MI_MASK     (0xF << LCD_PALLETTE_MONO_MI_BIT)
+  #define LCD_PALLETTE_MONO_MI_N(N)     (((N)<< LCD_PALLETTE_MONO_MI_BIT) & LCD_PALLETTE_MONO_MI_MASK)
+
+  #define LCD_PALLETTE_COLOR_RI_BIT     8
+  #define LCD_PALLETTE_COLOR_RI_MASK    (0xF << LCD_PALLETTE_COLOR_RI_BIT)
+  #define LCD_PALLETTE_COLOR_RI_N(N)    (((N)<< LCD_PALLETTE_COLOR_RI_BIT) & LCD_PALLETTE_COLOR_RI_MASK)
+  #define LCD_PALLETTE_COLOR_GI_BIT     4
+  #define LCD_PALLETTE_COLOR_GI_MASK    (0xF << LCD_PALLETTE_COLOR_GI_BIT)
+  #define LCD_PALLETTE_COLOR_GI_N(N)    (((N)<< LCD_PALLETTE_COLOR_GI_BIT) & LCD_PALLETTE_COLOR_GI_MASK)
+  #define LCD_PALLETTE_COLOR_BI_BIT     0
+  #define LCD_PALLETTE_COLOR_BI_MASK    (0xF << LCD_PALLETTE_COLOR_BI_BIT)
+  #define LCD_PALLETTE_COLOR_BI_N(N)    (((N)<< LCD_PALLETTE_COLOR_BI_BIT) & LCD_PALLETTE_COLOR_BI_MASK)
+
+  #define LCD_PALLETTE_TFT_DC_BIT       0
+  #define LCD_PALLETTE_TFT_DC_MASK      (0xFFFF << LCD_PALLETTE_TFT_DC_BIT)
+  #define LCD_PALLETTE_TFT_DC_N(N)      (((N)<< LCD_PALLETTE_TFT_DC_BIT) & LCD_PALLETTE_TFT_DC_MASK)
+
+/********************************************************************/
+
+/* List of panels known to work with the AU1100 LCD controller.
+ * To add a new panel, enter the same specifications as the
+ * Generic_TFT one, and MAKE SURE that it doesn't conflicts
+ * with the controller restrictions. Restrictions are:
+ *
+ * STN color panels: max_bpp <= 12
+ * STN mono panels: max_bpp <= 4
+ * TFT panels: max_bpp <= 16
+ * max_xres <= 800
+ * max_yres <= 600
  */
-struct known_lcd_panels panels[] =
+static struct au1100fb_panel known_lcd_panels[] =
 {
-        { /* 0: Pb1100 LCDA: Sharp 320x240 TFT panel */
-                320, /* xres */
-                240, /* yres */
-                16,  /* bpp  */
-
-                "Sharp_320x240_16",
-                /* mode_control */
+        /* 800x600x16bpp CRT */
+        [0] = {
+                .name = "CRT_800x600_16",
+                .xres = 800,
+                .yres = 600,
+                .bpp = 16,
+                .control_base = 0x0004886A |
+                        LCD_CONTROL_DEFAULT_PO | LCD_CONTROL_DEFAULT_SBPPF |
+                        LCD_CONTROL_BPP_16,
+                .clkcontrol_base = 0x00020000,
+                .horztiming = 0x005aff1f,
+                .verttiming = 0x16000e57,
+        },
+        /* just the standard LCD */
+        [1] = {
+                .name = "WWPC LCD",
+                .xres = 240,
+                .yres = 320,
+                .bpp = 16,
+                .control_base = 0x0006806A,
+                .horztiming = 0x0A1010EF,
+                .verttiming = 0x0301013F,
+                .clkcontrol_base = 0x00018001,
+        },
+        /* Sharp 320x240 TFT panel */
+        [2] = {
+                .name = "Sharp_LQ038Q5DR01",
+                .xres = 320,
+                .yres = 240,
+                .bpp = 16,
+                .control_base =
                 ( LCD_CONTROL_SBPPF_565
-                /*LCD_CONTROL_WP*/
-                /*LCD_CONTROL_WD*/
                 | LCD_CONTROL_C
                 | LCD_CONTROL_SM_0
-                /*LCD_CONTROL_DB*/
-                /*LCD_CONTROL_CCO*/
-                /*LCD_CONTROL_DP*/
-                | LCD_DEFAULT_PIX_FORMAT
-                /*LCD_CONTROL_MPI*/
+                        | LCD_CONTROL_DEFAULT_PO
                 | LCD_CONTROL_PT
                 | LCD_CONTROL_PC
                 | LCD_CONTROL_BPP_16 ),
-
-                /* mode_horztiming */
+                .horztiming =
                 ( LCD_HORZTIMING_HN2_N(8)
                 | LCD_HORZTIMING_HN1_N(60)
                 | LCD_HORZTIMING_HPW_N(12)
                 | LCD_HORZTIMING_PPL_N(320) ),
-
-                /* mode_verttiming */
+                .verttiming =
                 ( LCD_VERTTIMING_VN2_N(5)
                 | LCD_VERTTIMING_VN1_N(17)
                 | LCD_VERTTIMING_VPW_N(1)
                 | LCD_VERTTIMING_LPP_N(240) ),
-
-                /* mode_clkcontrol */
-                ( 0
-                /*LCD_CLKCONTROL_IB*/
-                /*LCD_CLKCONTROL_IC*/
-                /*LCD_CLKCONTROL_IH*/
-                /*LCD_CLKCONTROL_IV*/
-                | LCD_CLKCONTROL_PCD_N(1) ),
-
-                /* mode_pwmdiv */
-                0,
-
-                /* mode_pwmhi */
-                0,
-
-                /* mode_toyclksrc */
-                ((1<<7) | (1<<6) | (1<<5)),
-
-                /* mode_backlight */
-                6
+                .clkcontrol_base = LCD_CLKCONTROL_PCD_N(1),
         },
 
-        { /* 1: Pb1100 LCDC 640x480 TFT panel */
-                640, /* xres */
-                480, /* yres */
-                16,  /* bpp  */
-
-                "Generic_640x480_16",
-
-                /* mode_control */
-                0x004806a | LCD_DEFAULT_PIX_FORMAT,
-
-                /* mode_horztiming */
-                0x3434d67f,
-
-                /* mode_verttiming */
-                0x0e0e39df,
-
-                /* mode_clkcontrol */
-                ( 0
-                /*LCD_CLKCONTROL_IB*/
-                /*LCD_CLKCONTROL_IC*/
-                /*LCD_CLKCONTROL_IH*/
-                /*LCD_CLKCONTROL_IV*/
-                | LCD_CLKCONTROL_PCD_N(1) ),
-
-                /* mode_pwmdiv */
-                0,
-
-                /* mode_pwmhi */
-                0,
-
-                /* mode_toyclksrc */
-                ((1<<7) | (1<<6) | (0<<5)),
-
-                /* mode_backlight */
-                7
+        /* Hitachi SP14Q005 and possibly others */
+        [3] = {
+                .name = "Hitachi_SP14Qxxx",
+                .xres = 320,
+                .yres = 240,
+                .bpp = 4,
+                .control_base =
+                        ( LCD_CONTROL_C
+                        | LCD_CONTROL_BPP_4 ),
+                .horztiming =
+                        ( LCD_HORZTIMING_HN2_N(1)
+                        | LCD_HORZTIMING_HN1_N(1)
+                        | LCD_HORZTIMING_HPW_N(1)
+                        | LCD_HORZTIMING_PPL_N(320) ),
+                .verttiming =
+                        ( LCD_VERTTIMING_VN2_N(1)
+                        | LCD_VERTTIMING_VN1_N(1)
+                        | LCD_VERTTIMING_VPW_N(1)
+                        | LCD_VERTTIMING_LPP_N(240) ),
+                .clkcontrol_base = LCD_CLKCONTROL_PCD_N(4),
         },
 
-        { /* 2: Pb1100 LCDB 640x480 PrimeView TFT panel */
-                640, /* xres */
-                480, /* yres */
-                16,  /* bpp  */
-
-                "PrimeView_640x480_16",
-
-                /* mode_control */
-                0x0004886a | LCD_DEFAULT_PIX_FORMAT,
-
-                /* mode_horztiming */
-                0x0e4bfe7f,
-
-                /* mode_verttiming */
-                0x210805df,
-
-                /* mode_clkcontrol */
-                0x00038001,
-
-                /* mode_pwmdiv */
-                0,
-
-                /* mode_pwmhi */
-                0,
-
-                /* mode_toyclksrc */
-                ((1<<7) | (1<<6) | (0<<5)),
-
-                /* mode_backlight */
-                7
+        /* Generic 640x480 TFT panel */
+        [4] = {
+                .name = "TFT_640x480_16",
+                .xres = 640,
+                .yres = 480,
+                .bpp = 16,
+                .control_base = 0x004806a | LCD_CONTROL_DEFAULT_PO,
+                .horztiming = 0x3434d67f,
+                .verttiming = 0x0e0e39df,
+                .clkcontrol_base = LCD_CLKCONTROL_PCD_N(1),
         },
 
-        { /* 3: Pb1100 800x600x16bpp NEON CRT */
-                800, /* xres */
-                600, /* yres */
-                16,  /* bpp */
-
-                "NEON_800x600_16",
-
-                /* mode_control */
-                0x0004886A | LCD_DEFAULT_PIX_FORMAT,
-
-                /* mode_horztiming */
-                0x005AFF1F,
-
-                /* mode_verttiming */
-                0x16000E57,
-
-                /* mode_clkcontrol */
-                0x00020000,
-
-                /* mode_pwmdiv */
-                0,
-
-                /* mode_pwmhi */
-                0,
-
-                /* mode_toyclksrc */
-                ((1<<7) | (1<<6) | (0<<5)),
-
-                /* mode_backlight */
-                7
+         /* Pb1100 LCDB 640x480 PrimeView TFT panel */
+        [5] = {
+                .name = "PrimeView_640x480_16",
+                .xres = 640,
+                .yres = 480,
+                .bpp = 16,
+                .control_base = 0x0004886a | LCD_CONTROL_DEFAULT_PO,
+                .horztiming = 0x0e4bfe7f,
+                .verttiming = 0x210805df,
+                .clkcontrol_base = 0x00038001,
         },
+};
 
-        { /* 4: Pb1100 640x480x16bpp NEON CRT */
-                640, /* xres */
-                480, /* yres */
-                16,  /* bpp */
-
-                "NEON_640x480_16",
-
-                /* mode_control */
-                0x0004886A | LCD_DEFAULT_PIX_FORMAT,
-
-                /* mode_horztiming */
-                0x0052E27F,
-
-                /* mode_verttiming */
-                0x18000DDF,
-
-                /* mode_clkcontrol */
-                0x00020000,
+struct au1100fb_drv_info {
+        int     panel_idx;
+        char    *opt_mode;
+};
 
-                /* mode_pwmdiv */
-                0,
+/********************************************************************/
 
-                /* mode_pwmhi */
-                0,
+/* Inline helpers */
 
-                /* mode_toyclksrc */
-                ((1<<7) | (1<<6) | (0<<5)),
+#define panel_is_dual(panel)  (panel->control_base & LCD_CONTROL_DP)
+#define panel_is_active(panel)(panel->control_base & LCD_CONTROL_PT)
+#define panel_is_color(panel) (panel->control_base & LCD_CONTROL_PC)
+#define panel_swap_rgb(panel) (panel->control_base & LCD_CONTROL_CCO)
 
-                /* mode_backlight */
-                7
-        },
-};
 #endif /* _AU1100LCD_H */
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index 7e731691e2a9..6a9ae2b3d1ab 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -28,7 +28,7 @@ config VGA_CONSOLE
 
 config VIDEO_SELECT
         bool "Video mode selection support"
-        depends on  (X86 || X86_64) && VGA_CONSOLE
+        depends on  X86 && VGA_CONSOLE
         ---help---
           This enables support for text mode selection on kernel startup. If
           you want to take advantage of some high-resolution text mode your
diff --git a/drivers/video/console/newport_con.c b/drivers/video/console/newport_con.c
index e793ffd39db5..762c7a593141 100644
--- a/drivers/video/console/newport_con.c
+++ b/drivers/video/console/newport_con.c
@@ -32,7 +32,6 @@
 #include <linux/font.h>
 
 
-extern struct font_desc font_vga_8x16;
 extern unsigned long sgi_gfxaddr;
 
 #define FONT_DATA ((unsigned char *)font_vga_8x16.data)
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 809fee2140ac..56cd199605f4 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -579,6 +579,7 @@ static void vga_set_palette(struct vc_data *vc, unsigned char *table)
 {
         int i, j;
 
+        vga_w(state.vgabase, VGA_PEL_MSK, 0xff);
         for (i = j = 0; i < 16; i++) {
                 vga_w(state.vgabase, VGA_PEL_IW, table[i]);
                 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
@@ -721,6 +722,7 @@ static void vga_pal_blank(struct vgastate *state)
 {
         int i;
 
+        vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
         for (i = 0; i < 16; i++) {
                 vga_w(state->vgabase, VGA_PEL_IW, i);
                 vga_w(state->vgabase, VGA_PEL_D, 0);
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 9073be4221a8..e2667ddab3f1 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -918,7 +918,7 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
         }
 #endif
 #elif defined(__powerpc__)
-        vma->vm_page_prot = phys_mem_access_prot(file, off,
+        vma->vm_page_prot = phys_mem_access_prot(file, off >> PAGE_SHIFT,
                                                  vma->vm_end - vma->vm_start,
                                                  vma->vm_page_prot);
 #elif defined(__alpha__)
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index fc0a1beef968..316bfe994811 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -1126,7 +1126,7 @@ static int __init gbefb_probe(struct device *dev)
         gbefb_setup(options);
 #endif
 
-        if (!request_mem_region(GBE_BASE, sizeof(struct sgi_gbe), "GBE")) {
+        if (!request_region(GBE_BASE, sizeof(struct sgi_gbe), "GBE")) {
                 printk(KERN_ERR "gbefb: couldn't reserve mmio region\n");
                 ret = -EBUSY;
                 goto out_release_framebuffer;
@@ -1152,12 +1152,24 @@ static int __init gbefb_probe(struct device *dev)
         if (gbe_mem_phys) {
                 /* memory was allocated at boot time */
                 gbe_mem = ioremap_nocache(gbe_mem_phys, gbe_mem_size);
+                if (!gbe_mem) {
+                        printk(KERN_ERR "gbefb: couldn't map framebuffer\n");
+                        ret = -ENOMEM;
+                        goto out_tiles_free;
+                }
+
                 gbe_dma_addr = 0;
         } else {
                 /* try to allocate memory with the classical allocator
                  * this has high chance to fail on low memory machines */
                 gbe_mem = dma_alloc_coherent(NULL, gbe_mem_size, &gbe_dma_addr,
                                              GFP_KERNEL);
+                if (!gbe_mem) {
+                        printk(KERN_ERR "gbefb: couldn't allocate framebuffer memory\n");
+                        ret = -ENOMEM;
+                        goto out_tiles_free;
+                }
+
                 gbe_mem_phys = (unsigned long) gbe_dma_addr;
         }
 
@@ -1165,12 +1177,6 @@ static int __init gbefb_probe(struct device *dev)
         mtrr_add(gbe_mem_phys, gbe_mem_size, MTRR_TYPE_WRCOMB, 1);
 #endif
 
-        if (!gbe_mem) {
-                printk(KERN_ERR "gbefb: couldn't map framebuffer\n");
-                ret = -ENXIO;
-                goto out_tiles_free;
-        }
-
         /* map framebuffer memory into tiles table */
         for (i = 0; i < (gbe_mem_size >> TILE_SHIFT); i++)
                 gbe_tiles.cpu[i] = (gbe_mem_phys >> TILE_SHIFT) + i;
diff --git a/drivers/w1/w1_family.c b/drivers/w1/w1_family.c
index 88c517a4c178..9e293e139a0e 100644
--- a/drivers/w1/w1_family.c
+++ b/drivers/w1/w1_family.c
@@ -21,6 +21,7 @@
 
 #include <linux/spinlock.h>
 #include <linux/list.h>
+#include <linux/sched.h>        /* schedule_timeout() */
 #include <linux/delay.h>
 
 #include "w1_family.h"
diff --git a/drivers/zorro/zorro-sysfs.c b/drivers/zorro/zorro-sysfs.c
index 04ca8840acf1..87c29d7b6c17 100644
--- a/drivers/zorro/zorro-sysfs.c
+++ b/drivers/zorro/zorro-sysfs.c
@@ -14,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/zorro.h>
 #include <linux/stat.h>
+#include <linux/string.h>
 
 #include "zorro.h"
 
diff --git a/drivers/zorro/zorro.c b/drivers/zorro/zorro.c
index d3c05dfe20d2..0f2b40605b06 100644
--- a/drivers/zorro/zorro.c
+++ b/drivers/zorro/zorro.c
@@ -16,6 +16,8 @@
 #include <linux/init.h>
 #include <linux/zorro.h>
 #include <linux/bitops.h>
+#include <linux/string.h>
+
 #include <asm/setup.h>
 #include <asm/amigahw.h>