115 files changed, 4981 insertions, 745 deletions
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index e35525b39f6b..c79e789ed03a 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -71,7 +71,7 @@ struct acpi_table_attr {
        struct list_head node;
 };
-static ssize_t acpi_table_show(struct kobject *kobj,
+static ssize_t acpi_table_show(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr, char *buf,
                               loff_t offset, size_t count)
 {
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index fd52c48ee762..ef38aff737eb 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -18,9 +18,9 @@ config UEVENT_HELPER_PATH
 config DEVTMPFS
        bool "Maintain a devtmpfs filesystem to mount at /dev"
-        depends on HOTPLUG && SHMEM && TMPFS
+        depends on HOTPLUG
        help
-          This creates a tmpfs filesystem instance early at bootup.
+          This creates a tmpfs/ramfs filesystem instance early at bootup.
          In this filesystem, the kernel driver core maintains device
          nodes with their default names and permissions for all
          registered devices with an assigned major/minor number.
@@ -33,6 +33,9 @@ config DEVTMPFS
          functional /dev without any further help. It also allows simple
          rescue systems, and reliably handles dynamic major/minor numbers.
+          Notice: if CONFIG_TMPFS isn't enabled, the simpler ramfs
+          file system will be used instead.
 config DEVTMPFS_MOUNT
        bool "Automount devtmpfs at /dev, after the kernel mounted the rootfs"
        depends on DEVTMPFS
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 9c6a0d6408e7..8e231d05b400 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -63,6 +63,14 @@ static void class_release(struct kobject *kobj)
        kfree(cp);
 }
+static const struct kobj_ns_type_operations *class_child_ns_type(struct kobject *kobj)
+{
+        struct class_private *cp = to_class(kobj);
+        struct class *class = cp->class;
+        return class->ns_type;
+}
 static const struct sysfs_ops class_sysfs_ops = {
        .show   = class_attr_show,
        .store  = class_attr_store,
@@ -71,6 +79,7 @@ static const struct sysfs_ops class_sysfs_ops = {
 static struct kobj_type class_ktype = {
        .sysfs_ops      = &class_sysfs_ops,
        .release        = class_release,
+        .child_ns_type  = class_child_ns_type,
 };
 /* Hotplug events for classes go to the class class_subsys */
diff --git a/drivers/base/core.c b/drivers/base/core.c
index b56a0ba31d4a..9630fbdf4e6c 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -20,7 +20,6 @@
 #include <linux/notifier.h>
 #include <linux/genhd.h>
 #include <linux/kallsyms.h>
-#include <linux/semaphore.h>
 #include <linux/mutex.h>
 #include <linux/async.h>
@@ -132,9 +131,21 @@ static void device_release(struct kobject *kobj)
        kfree(p);
 }
+static const void *device_namespace(struct kobject *kobj)
+{
+        struct device *dev = to_dev(kobj);
+        const void *ns = NULL;
+        if (dev->class && dev->class->ns_type)
+                ns = dev->class->namespace(dev);
+        return ns;
+}
 static struct kobj_type device_ktype = {
        .release        = device_release,
        .sysfs_ops      = &dev_sysfs_ops,
+        .namespace      = device_namespace,
 };
@@ -559,10 +570,10 @@ void device_initialize(struct device *dev)
        dev->kobj.kset = devices_kset;
        kobject_init(&dev->kobj, &device_ktype);
        INIT_LIST_HEAD(&dev->dma_pools);
-        init_MUTEX(&dev->sem);
+        mutex_init(&dev->mutex);
+        lockdep_set_novalidate_class(&dev->mutex);
        spin_lock_init(&dev->devres_lock);
        INIT_LIST_HEAD(&dev->devres_head);
-        device_init_wakeup(dev, 0);
        device_pm_init(dev);
        set_dev_node(dev, -1);
 }
@@ -596,11 +607,59 @@ static struct kobject *virtual_device_parent(struct device *dev)
        return virtual_dir;
 }
-static struct kobject *get_device_parent(struct device *dev,
+struct class_dir {
-                                         struct device *parent)
+        struct kobject kobj;
+        struct class *class;
+};
+#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
+static void class_dir_release(struct kobject *kobj)
+{
+        struct class_dir *dir = to_class_dir(kobj);
+        kfree(dir);
+}
+static const
+struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
 {
+        struct class_dir *dir = to_class_dir(kobj);
+        return dir->class->ns_type;
+}
+static struct kobj_type class_dir_ktype = {
+        .release        = class_dir_release,
+        .sysfs_ops      = &kobj_sysfs_ops,
+        .child_ns_type  = class_dir_child_ns_type
+};
+static struct kobject *
+class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
+{
+        struct class_dir *dir;
        int retval;
+        dir = kzalloc(sizeof(*dir), GFP_KERNEL);
+        if (!dir)
+                return NULL;
+        dir->class = class;
+        kobject_init(&dir->kobj, &class_dir_ktype);
+        dir->kobj.kset = &class->p->class_dirs;
+        retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
+        if (retval < 0) {
+                kobject_put(&dir->kobj);
+                return NULL;
+        }
+        return &dir->kobj;
+}
+static struct kobject *get_device_parent(struct device *dev,
+                                         struct device *parent)
+{
        if (dev->class) {
                static DEFINE_MUTEX(gdp_mutex);
                struct kobject *kobj = NULL;
@@ -635,18 +694,7 @@ static struct kobject *get_device_parent(struct device *dev,
                }
                /* or create a new class-directory at the parent device */
-                k = kobject_create();
+                k = class_dir_create_and_add(dev->class, parent_kobj);
-                if (!k) {
-                        mutex_unlock(&gdp_mutex);
-                        return NULL;
-                }
-                k->kset = &dev->class->p->class_dirs;
-                retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
-                if (retval < 0) {
-                        mutex_unlock(&gdp_mutex);
-                        kobject_put(k);
-                        return NULL;
-                }
                /* do not emit an uevent for this simple "glue" directory */
                mutex_unlock(&gdp_mutex);
                return k;
@@ -738,7 +786,7 @@ out_device:
 out_busid:
        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
            device_is_not_partition(dev))
-                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
+                sysfs_delete_link(&dev->class->p->class_subsys.kobj, &dev->kobj,
                                  dev_name(dev));
 #else
        /* link in the class directory pointing to the device */
@@ -756,7 +804,7 @@ out_busid:
        return 0;
 out_busid:
-        sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
+        sysfs_delete_link(&dev->class->p->class_subsys.kobj, &dev->kobj, dev_name(dev));
 #endif
 out_subsys:
@@ -784,13 +832,13 @@ static void device_remove_class_symlinks(struct device *dev)
        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
            device_is_not_partition(dev))
-                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
+                sysfs_delete_link(&dev->class->p->class_subsys.kobj, &dev->kobj,
                                  dev_name(dev));
 #else
        if (dev->parent && device_is_not_partition(dev))
                sysfs_remove_link(&dev->kobj, "device");
-        sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
+        sysfs_delete_link(&dev->class->p->class_subsys.kobj, &dev->kobj, dev_name(dev));
 #endif
        sysfs_remove_link(&dev->kobj, "subsystem");
@@ -1372,7 +1420,7 @@ struct device *__root_device_register(const char *name, struct module *owner)
                return ERR_PTR(err);
        }
-#ifdef CONFIG_MODULE    /* gotta find a "cleaner" way to do this */
+#ifdef CONFIG_MODULES   /* gotta find a "cleaner" way to do this */
        if (owner) {
                struct module_kobject *mk = &owner->mkobj;
@@ -1576,6 +1624,14 @@ int device_rename(struct device *dev, char *new_name)
                goto out;
        }
+#ifndef CONFIG_SYSFS_DEPRECATED
+        if (dev->class) {
+                error = sysfs_rename_link(&dev->class->p->class_subsys.kobj,
+                        &dev->kobj, old_device_name, new_name);
+                if (error)
+                        goto out;
+        }
+#endif
        error = kobject_rename(&dev->kobj, new_name);
        if (error)
                goto out;
@@ -1590,11 +1646,6 @@ int device_rename(struct device *dev, char *new_name)
                                                  new_class_name);
                }
        }
-#else
-        if (dev->class) {
-                error = sysfs_rename_link(&dev->class->p->class_subsys.kobj,
-                                          &dev->kobj, old_device_name, new_name);
-        }
 #endif
 out:
@@ -1735,10 +1786,25 @@ EXPORT_SYMBOL_GPL(device_move);
 */
 void device_shutdown(void)
 {
-        struct device *dev, *devn;
+        struct device *dev;
+        spin_lock(&devices_kset->list_lock);
+        /*
+         * Walk the devices list backward, shutting down each in turn.
+         * Beware that device unplug events may also start pulling
+         * devices offline, even as the system is shutting down.
+         */
+        while (!list_empty(&devices_kset->list)) {
+                dev = list_entry(devices_kset->list.prev, struct device,
+                                kobj.entry);
+                get_device(dev);
+                /*
+                 * Make sure the device is off the kset list, in the
+                 * event that dev->*->shutdown() doesn't remove it.
+                 */
+                list_del_init(&dev->kobj.entry);
+                spin_unlock(&devices_kset->list_lock);
-        list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list,
-                                kobj.entry) {
                if (dev->bus && dev->bus->shutdown) {
                        dev_dbg(dev, "shutdown\n");
                        dev->bus->shutdown(dev);
@@ -1746,6 +1812,10 @@ void device_shutdown(void)
                        dev_dbg(dev, "shutdown\n");
                        dev->driver->shutdown(dev);
                }
+                put_device(dev);
+                spin_lock(&devices_kset->list_lock);
        }
+        spin_unlock(&devices_kset->list_lock);
        async_synchronize_full();
 }
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index f35719aab3c1..251acea3d359 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -186,7 +186,7 @@ static ssize_t print_cpus_offline(struct sysdev_class *class,
        /* display offline cpus < nr_cpu_ids */
        if (!alloc_cpumask_var(&offline, GFP_KERNEL))
                return -ENOMEM;
-        cpumask_complement(offline, cpu_online_mask);
+        cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
        n = cpulist_scnprintf(buf, len, offline);
        free_cpumask_var(offline);
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index c89291f8a16b..503c2620bbcc 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -40,11 +40,11 @@ static void driver_bound(struct device *dev)
        pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
                 __func__, dev->driver->name);
+        klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
        if (dev->bus)
                blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                             BUS_NOTIFY_BOUND_DRIVER, dev);
-        klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
 }
 static int driver_sysfs_add(struct device *dev)
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 057cf11326bf..af0600143d1c 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -20,6 +20,7 @@
 #include <linux/namei.h>
 #include <linux/fs.h>
 #include <linux/shmem_fs.h>
+#include <linux/ramfs.h>
 #include <linux/cred.h>
 #include <linux/sched.h>
 #include <linux/init_task.h>
@@ -45,7 +46,11 @@ __setup("devtmpfs.mount=", mount_param);
 static int dev_get_sb(struct file_system_type *fs_type, int flags,
                      const char *dev_name, void *data, struct vfsmount *mnt)
 {
+#ifdef CONFIG_TMPFS
        return get_sb_single(fs_type, flags, data, shmem_fill_super, mnt);
+#else
+        return get_sb_single(fs_type, flags, data, ramfs_fill_super, mnt);
+#endif
 }
 static struct file_system_type dev_fs_type = {
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 985da11174e7..3f093b0dd217 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -27,6 +27,52 @@ MODULE_AUTHOR("Manuel Estrada Sainz");
 MODULE_DESCRIPTION("Multi purpose firmware loading support");
 MODULE_LICENSE("GPL");
+/* Builtin firmware support */
+#ifdef CONFIG_FW_LOADER
+extern struct builtin_fw __start_builtin_fw[];
+extern struct builtin_fw __end_builtin_fw[];
+static bool fw_get_builtin_firmware(struct firmware *fw, const char *name)
+{
+        struct builtin_fw *b_fw;
+        for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
+                if (strcmp(name, b_fw->name) == 0) {
+                        fw->size = b_fw->size;
+                        fw->data = b_fw->data;
+                        return true;
+                }
+        }
+        return false;
+}
+static bool fw_is_builtin_firmware(const struct firmware *fw)
+{
+        struct builtin_fw *b_fw;
+        for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
+                if (fw->data == b_fw->data)
+                        return true;
+        return false;
+}
+#else /* Module case - no builtin firmware support */
+static inline bool fw_get_builtin_firmware(struct firmware *fw, const char *name)
+{
+        return false;
+}
+static inline bool fw_is_builtin_firmware(const struct firmware *fw)
+{
+        return false;
+}
+#endif
 enum {
        FW_STATUS_LOADING,
        FW_STATUS_DONE,
@@ -40,7 +86,6 @@ static int loading_timeout = 60;	/* In seconds */
 static DEFINE_MUTEX(fw_lock);
 struct firmware_priv {
-        char *fw_id;
        struct completion completion;
        struct bin_attribute attr_data;
        struct firmware *fw;
@@ -48,18 +93,11 @@ struct firmware_priv {
        struct page **pages;
        int nr_pages;
        int page_array_size;
-        const char *vdata;
        struct timer_list timeout;
+        bool nowait;
+        char fw_id[];
 };
-#ifdef CONFIG_FW_LOADER
-extern struct builtin_fw __start_builtin_fw[];
-extern struct builtin_fw __end_builtin_fw[];
-#else /* Module case. Avoid ifdefs later; it'll all optimise out */
-static struct builtin_fw *__start_builtin_fw;
-static struct builtin_fw *__end_builtin_fw;
-#endif
 static void
 fw_load_abort(struct firmware_priv *fw_priv)
 {
@@ -100,9 +138,25 @@ firmware_timeout_store(struct class *class,
        return count;
 }
-static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);
+static struct class_attribute firmware_class_attrs[] = {
+        __ATTR(timeout, S_IWUSR | S_IRUGO,
+                firmware_timeout_show, firmware_timeout_store),
+        __ATTR_NULL
+};
+static void fw_dev_release(struct device *dev)
+{
+        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        int i;
+        for (i = 0; i < fw_priv->nr_pages; i++)
+                __free_page(fw_priv->pages[i]);
+        kfree(fw_priv->pages);
+        kfree(fw_priv);
+        kfree(dev);
-static void fw_dev_release(struct device *dev);
+        module_put(THIS_MODULE);
+}
 static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
@@ -112,12 +166,15 @@ static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
                return -ENOMEM;
        if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
                return -ENOMEM;
+        if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
+                return -ENOMEM;
        return 0;
 }
 static struct class firmware_class = {
        .name           = "firmware",
+        .class_attrs    = firmware_class_attrs,
        .dev_uevent     = firmware_uevent,
        .dev_release    = fw_dev_release,
 };
@@ -130,6 +187,17 @@ static ssize_t firmware_loading_show(struct device *dev,
        return sprintf(buf, "%d\n", loading);
 }
+static void firmware_free_data(const struct firmware *fw)
+{
+        int i;
+        vunmap(fw->data);
+        if (fw->pages) {
+                for (i = 0; i < PFN_UP(fw->size); i++)
+                        __free_page(fw->pages[i]);
+                kfree(fw->pages);
+        }
+}
 /* Some architectures don't have PAGE_KERNEL_RO */
 #ifndef PAGE_KERNEL_RO
 #define PAGE_KERNEL_RO PAGE_KERNEL
@@ -162,21 +230,21 @@ static ssize_t firmware_loading_store(struct device *dev,
                        mutex_unlock(&fw_lock);
                        break;
                }
-                vfree(fw_priv->fw->data);
+                firmware_free_data(fw_priv->fw);
-                fw_priv->fw->data = NULL;
+                memset(fw_priv->fw, 0, sizeof(struct firmware));
+                /* If the pages are not owned by 'struct firmware' */
                for (i = 0; i < fw_priv->nr_pages; i++)
                        __free_page(fw_priv->pages[i]);
                kfree(fw_priv->pages);
                fw_priv->pages = NULL;
                fw_priv->page_array_size = 0;
                fw_priv->nr_pages = 0;
-                fw_priv->fw->size = 0;
                set_bit(FW_STATUS_LOADING, &fw_priv->status);
                mutex_unlock(&fw_lock);
                break;
        case 0:
                if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
-                        vfree(fw_priv->fw->data);
+                        vunmap(fw_priv->fw->data);
                        fw_priv->fw->data = vmap(fw_priv->pages,
                                                 fw_priv->nr_pages,
                                                 0, PAGE_KERNEL_RO);
@@ -184,7 +252,10 @@ static ssize_t firmware_loading_store(struct device *dev,
                                dev_err(dev, "%s: vmap() failed\n", __func__);
                                goto err;
                        }
-                        /* Pages will be freed by vfree() */
+                        /* Pages are now owned by 'struct firmware' */
+                        fw_priv->fw->pages = fw_priv->pages;
+                        fw_priv->pages = NULL;
                        fw_priv->page_array_size = 0;
                        fw_priv->nr_pages = 0;
                        complete(&fw_priv->completion);
@@ -207,8 +278,9 @@ static ssize_t firmware_loading_store(struct device *dev,
 static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
 static ssize_t
-firmware_data_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+firmware_data_read(struct file *filp, struct kobject *kobj,
-                   char *buffer, loff_t offset, size_t count)
+                   struct bin_attribute *bin_attr, char *buffer, loff_t offset,
+                   size_t count)
 {
        struct device *dev = to_dev(kobj);
        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
@@ -291,6 +363,7 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
 /**
 * firmware_data_write - write method for firmware
+ * @filp: open sysfs file
 * @kobj: kobject for the device
 * @bin_attr: bin_attr structure
 * @buffer: buffer being written
@@ -301,8 +374,9 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
 *      the driver as a firmware image.
 **/
 static ssize_t
-firmware_data_write(struct kobject *kobj, struct bin_attribute *bin_attr,
+firmware_data_write(struct file* filp, struct kobject *kobj,
-                    char *buffer, loff_t offset, size_t count)
+                    struct bin_attribute *bin_attr, char *buffer,
+                    loff_t offset, size_t count)
 {
        struct device *dev = to_dev(kobj);
        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
@@ -353,21 +427,6 @@ static struct bin_attribute firmware_attr_data_tmpl = {
        .write = firmware_data_write,
 };
-static void fw_dev_release(struct device *dev)
-{
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
-        int i;
-        for (i = 0; i < fw_priv->nr_pages; i++)
-                __free_page(fw_priv->pages[i]);
-        kfree(fw_priv->pages);
-        kfree(fw_priv->fw_id);
-        kfree(fw_priv);
-        kfree(dev);
-        module_put(THIS_MODULE);
-}
 static void
 firmware_class_timeout(u_long data)
 {
@@ -379,8 +438,8 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
                              struct device *device)
 {
        int retval;
-        struct firmware_priv *fw_priv = kzalloc(sizeof(*fw_priv),
+        struct firmware_priv *fw_priv =
-                                                GFP_KERNEL);
+                kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
        struct device *f_dev = kzalloc(sizeof(*f_dev), GFP_KERNEL);
        *dev_p = NULL;
@@ -391,16 +450,9 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
                goto error_kfree;
        }
+        strcpy(fw_priv->fw_id, fw_name);
        init_completion(&fw_priv->completion);
        fw_priv->attr_data = firmware_attr_data_tmpl;
-        fw_priv->fw_id = kstrdup(fw_name, GFP_KERNEL);
-        if (!fw_priv->fw_id) {
-                dev_err(device, "%s: Firmware name allocation failed\n",
-                        __func__);
-                retval = -ENOMEM;
-                goto error_kfree;
-        }
        fw_priv->timeout.function = firmware_class_timeout;
        fw_priv->timeout.data = (u_long) fw_priv;
        init_timer(&fw_priv->timeout);
@@ -427,7 +479,7 @@ error_kfree:
 static int fw_setup_device(struct firmware *fw, struct device **dev_p,
                           const char *fw_name, struct device *device,
-                           int uevent)
+                           int uevent, bool nowait)
 {
        struct device *f_dev;
        struct firmware_priv *fw_priv;
@@ -443,6 +495,8 @@ static int fw_setup_device(struct firmware *fw, struct device **dev_p,
        fw_priv = dev_get_drvdata(f_dev);
+        fw_priv->nowait = nowait;
        fw_priv->fw = fw;
        sysfs_bin_attr_init(&fw_priv->attr_data);
        retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data);
@@ -470,12 +524,11 @@ out:
 static int
 _request_firmware(const struct firmware **firmware_p, const char *name,
-                 struct device *device, int uevent)
+                 struct device *device, int uevent, bool nowait)
 {
        struct device *f_dev;
        struct firmware_priv *fw_priv;
        struct firmware *firmware;
-        struct builtin_fw *builtin;
        int retval;
        if (!firmware_p)
@@ -489,21 +542,16 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
                goto out;
        }
-        for (builtin = __start_builtin_fw; builtin != __end_builtin_fw;
+        if (fw_get_builtin_firmware(firmware, name)) {
-             builtin++) {
+                dev_dbg(device, "firmware: using built-in firmware %s\n", name);
-                if (strcmp(name, builtin->name))
-                        continue;
-                dev_info(device, "firmware: using built-in firmware %s\n",
-                         name);
-                firmware->size = builtin->size;
-                firmware->data = builtin->data;
                return 0;
        }
        if (uevent)
-                dev_info(device, "firmware: requesting %s\n", name);
+                dev_dbg(device, "firmware: requesting %s\n", name);
-        retval = fw_setup_device(firmware, &f_dev, name, device, uevent);
+        retval = fw_setup_device(firmware, &f_dev, name, device,
+                                 uevent, nowait);
        if (retval)
                goto error_kfree_fw;
@@ -560,26 +608,18 @@ request_firmware(const struct firmware **firmware_p, const char *name,
                 struct device *device)
 {
        int uevent = 1;
-        return _request_firmware(firmware_p, name, device, uevent);
+        return _request_firmware(firmware_p, name, device, uevent, false);
 }
 /**
 * release_firmware: - release the resource associated with a firmware image
 * @fw: firmware resource to release
 **/
-void
+void release_firmware(const struct firmware *fw)
-release_firmware(const struct firmware *fw)
 {
-        struct builtin_fw *builtin;
        if (fw) {
-                for (builtin = __start_builtin_fw; builtin != __end_builtin_fw;
+                if (!fw_is_builtin_firmware(fw))
-                     builtin++) {
+                        firmware_free_data(fw);
-                        if (fw->data == builtin->data)
-                                goto free_fw;
-                }
-                vfree(fw->data);
-        free_fw:
                kfree(fw);
        }
 }
@@ -606,7 +646,7 @@ request_firmware_work_func(void *arg)
                return 0;
        }
        ret = _request_firmware(&fw, fw_work->name, fw_work->device,
-                fw_work->uevent);
+                fw_work->uevent, true);
        fw_work->cont(fw, fw_work->context);
@@ -670,26 +710,12 @@ request_firmware_nowait(
        return 0;
 }
-static int __init
+static int __init firmware_class_init(void)
-firmware_class_init(void)
 {
-        int error;
+        return class_register(&firmware_class);
-        error = class_register(&firmware_class);
-        if (error) {
-                printk(KERN_ERR "%s: class_register failed\n", __func__);
-                return error;
-        }
-        error = class_create_file(&firmware_class, &class_attr_timeout);
-        if (error) {
-                printk(KERN_ERR "%s: class_create_file failed\n",
-                       __func__);
-                class_unregister(&firmware_class);
-        }
-        return error;
 }
-static void __exit
-firmware_class_exit(void)
+static void __exit firmware_class_exit(void)
 {
        class_unregister(&firmware_class);
 }
diff --git a/drivers/base/module.c b/drivers/base/module.c
index f32f2f9b7be5..db930d3ee312 100644
--- a/drivers/base/module.c
+++ b/drivers/base/module.c
@@ -15,12 +15,10 @@ static char *make_driver_name(struct device_driver *drv)
 {
        char *driver_name;
-        driver_name = kmalloc(strlen(drv->name) + strlen(drv->bus->name) + 2,
+        driver_name = kasprintf(GFP_KERNEL, "%s:%s", drv->bus->name, drv->name);
-                              GFP_KERNEL);
        if (!driver_name)
                return NULL;
-        sprintf(driver_name, "%s:%s", drv->bus->name, drv->name);
        return driver_name;
 }
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index ada6397c23a5..4d99c8bdfedc 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -735,7 +735,7 @@ static void platform_pm_complete(struct device *dev)
 #ifdef CONFIG_SUSPEND
-static int platform_pm_suspend(struct device *dev)
+int __weak platform_pm_suspend(struct device *dev)
 {
        struct device_driver *drv = dev->driver;
        int ret = 0;
@@ -753,7 +753,7 @@ static int platform_pm_suspend(struct device *dev)
        return ret;
 }
-static int platform_pm_suspend_noirq(struct device *dev)
+int __weak platform_pm_suspend_noirq(struct device *dev)
 {
        struct device_driver *drv = dev->driver;
        int ret = 0;
@@ -769,7 +769,7 @@ static int platform_pm_suspend_noirq(struct device *dev)
        return ret;
 }
-static int platform_pm_resume(struct device *dev)
+int __weak platform_pm_resume(struct device *dev)
 {
        struct device_driver *drv = dev->driver;
        int ret = 0;
@@ -787,7 +787,7 @@ static int platform_pm_resume(struct device *dev)
        return ret;
 }
-static int platform_pm_resume_noirq(struct device *dev)
+int __weak platform_pm_resume_noirq(struct device *dev)
 {
        struct device_driver *drv = dev->driver;
        int ret = 0;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 8546d123b9a7..a90e83c9be96 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -835,6 +835,8 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
        set_capacity(lo->lo_disk, size);
        bd_set_size(bdev, size << 9);
+        /* let user-space know about the new size */
+        kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
        set_blocksize(bdev, lo_blocksize);
@@ -858,6 +860,7 @@ out_clr:
        set_capacity(lo->lo_disk, 0);
        invalidate_bdev(bdev);
        bd_set_size(bdev, 0);
+        kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
        mapping_set_gfp_mask(mapping, lo->old_gfp_mask);
        lo->lo_state = Lo_unbound;
 out_putf:
@@ -944,8 +947,11 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
        if (bdev)
                invalidate_bdev(bdev);
        set_capacity(lo->lo_disk, 0);
-        if (bdev)
+        if (bdev) {
                bd_set_size(bdev, 0);
+                /* let user-space know about this change */
+                kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
+        }
        mapping_set_gfp_mask(filp->f_mapping, gfp);
        lo->lo_state = Lo_unbound;
        /* This is safe: open() is still holding a reference. */
@@ -1189,6 +1195,8 @@ static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev)
        sz <<= 9;
        mutex_lock(&bdev->bd_mutex);
        bd_set_size(bdev, sz);
+        /* let user-space know about the new size */
+        kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
        mutex_unlock(&bdev->bd_mutex);
 out:
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 3141dd3b6e53..e21175be25d0 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -276,11 +276,19 @@ config N_HDLC
          Allows synchronous HDLC communications with tty device drivers that
          support synchronous HDLC such as the Microgate SyncLink adapter.
-          This driver can only be built as a module ( = code which can be
+          This driver can be built as a module ( = code which can be
          inserted in and removed from the running kernel whenever you want).
          The module will be called n_hdlc. If you want to do that, say M
          here.
+config N_GSM
+        tristate "GSM MUX line discipline support (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        depends on NET
+        help
+          This line discipline provides support for the GSM MUX protocol and
+          presents the mux as a set of 61 individual tty devices.
 config RISCOM8
        tristate "SDL RISCom/8 card support"
        depends on SERIAL_NONSTANDARD
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index f957edf7e45d..d39be4cf1f5d 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_SYNCLINK)		+= synclink.o
 obj-$(CONFIG_SYNCLINKMP)        += synclinkmp.o
 obj-$(CONFIG_SYNCLINK_GT)       += synclink_gt.o
 obj-$(CONFIG_N_HDLC)            += n_hdlc.o
+obj-$(CONFIG_N_GSM)             += n_gsm.o
 obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o
 obj-$(CONFIG_SX)                += sx.o generic_serial.o
 obj-$(CONFIG_RIO)               += rio/ generic_serial.o
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index c1ab303455cf..98310e1aae30 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -1573,11 +1573,16 @@ static int __devinit isicom_probe(struct pci_dev *pdev,
        dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
        /* allot the first empty slot in the array */
-        for (index = 0; index < BOARD_COUNT; index++)
+        for (index = 0; index < BOARD_COUNT; index++) {
                if (isi_card[index].base == 0) {
                        board = &isi_card[index];
                        break;
                }
+        }
+        if (index == BOARD_COUNT) {
+                retval = -ENODEV;
+                goto err_disable;
+        }
        board->index = index;
        board->base = pci_resource_start(pdev, 3);
@@ -1624,6 +1629,7 @@ errunrr:
 errdec:
        board->base = 0;
        card_count--;
+err_disable:
        pci_disable_device(pdev);
 err:
        return retval;
diff --git a/drivers/char/n_gsm.c b/drivers/char/n_gsm.c
new file mode 100644
index 000000000000..c4161d5e053d
--- /dev/null
+++ b/drivers/char/n_gsm.c
@@ -0,0 +1,2763 @@
+/*
+ * n_gsm.c GSM 0710 tty multiplexor
+ * Copyright (c) 2009/10 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ *
+ *      * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
+ *
+ * TO DO:
+ *      Mostly done:    ioctls for setting modes/timing
+ *      Partly done:    hooks so you can pull off frames to non tty devs
+ *      Restart DLCI 0 when it closes ?
+ *      Test basic encoding
+ *      Improve the tx engine
+ *      Resolve tx side locking by adding a queue_head and routing
+ *              all control traffic via it
+ *      General tidy/document
+ *      Review the locking/move to refcounts more (mux now moved to an
+ *              alloc/free model ready)
+ *      Use newest tty open/close port helpers and install hooks
+ *      What to do about power functions ?
+ *      Termios setting and negotiation
+ *      Do we need a 'which mux are you' ioctl to correlate mux and tty sets
+ *
+ */
+#include <linux/types.h>
+#include <linux/major.h>
+#include <linux/errno.h>
+#include <linux/signal.h>
+#include <linux/fcntl.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/tty.h>
+#include <linux/timer.h>
+#include <linux/ctype.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <linux/bitops.h>
+#include <linux/file.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/timer.h>
+#include <linux/tty_flip.h>
+#include <linux/tty_driver.h>
+#include <linux/serial.h>
+#include <linux/kfifo.h>
+#include <linux/skbuff.h>
+#include <linux/gsmmux.h>
+static int debug;
+module_param(debug, int, 0600);
+#define T1      (HZ/10)
+#define T2      (HZ/3)
+#define N2      3
+/* Use long timers for testing at low speed with debug on */
+#ifdef DEBUG_TIMING
+#define T1      HZ
+#define T2      (2 * HZ)
+#endif
+/* Semi-arbitary buffer size limits. 0710 is normally run with 32-64 byte
+   limits so this is plenty */
+#define MAX_MRU 512
+#define MAX_MTU 512
+/*
+ *      Each block of data we have queued to go out is in the form of
+ *      a gsm_msg which holds everything we need in a link layer independant
+ *      format
+ */
+struct gsm_msg {
+        struct gsm_msg *next;
+        u8 addr;                /* DLCI address + flags */
+        u8 ctrl;                /* Control byte + flags */
+        unsigned int len;       /* Length of data block (can be zero) */
+        unsigned char *data;    /* Points into buffer but not at the start */
+        unsigned char buffer[0];
+};
+/*
+ *      Each active data link has a gsm_dlci structure associated which ties
+ *      the link layer to an optional tty (if the tty side is open). To avoid
+ *      complexity right now these are only ever freed up when the mux is
+ *      shut down.
+ *
+ *      At the moment we don't free DLCI objects until the mux is torn down
+ *      this avoid object life time issues but might be worth review later.
+ */
+struct gsm_dlci {
+        struct gsm_mux *gsm;
+        int addr;
+        int state;
+#define DLCI_CLOSED             0
+#define DLCI_OPENING            1       /* Sending SABM not seen UA */
+#define DLCI_OPEN               2       /* SABM/UA complete */
+#define DLCI_CLOSING            3       /* Sending DISC not seen UA/DM */
+        /* Link layer */
+        spinlock_t lock;        /* Protects the internal state */
+        struct timer_list t1;   /* Retransmit timer for SABM and UA */
+        int retries;
+        /* Uplink tty if active */
+        struct tty_port port;   /* The tty bound to this DLCI if there is one */
+        struct kfifo *fifo;     /* Queue fifo for the DLCI */
+        struct kfifo _fifo;     /* For new fifo API porting only */
+        int adaption;           /* Adaption layer in use */
+        u32 modem_rx;           /* Our incoming virtual modem lines */
+        u32 modem_tx;           /* Our outgoing modem lines */
+        int dead;               /* Refuse re-open */
+        /* Flow control */
+        int throttled;          /* Private copy of throttle state */
+        int constipated;        /* Throttle status for outgoing */
+        /* Packetised I/O */
+        struct sk_buff *skb;    /* Frame being sent */
+        struct sk_buff_head skb_list;   /* Queued frames */
+        /* Data handling callback */
+        void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
+};
+/* DLCI 0, 62/63 are special or reseved see gsmtty_open */
+#define NUM_DLCI                64
+/*
+ *      DLCI 0 is used to pass control blocks out of band of the data
+ *      flow (and with a higher link priority). One command can be outstanding
+ *      at a time and we use this structure to manage them. They are created
+ *      and destroyed by the user context, and updated by the receive paths
+ *      and timers
+ */
+struct gsm_control {
+        u8 cmd;         /* Command we are issuing */
+        u8 *data;       /* Data for the command in case we retransmit */
+        int len;        /* Length of block for retransmission */
+        int done;       /* Done flag */
+        int error;      /* Error if any */
+};
+/*
+ *      Each GSM mux we have is represented by this structure. If we are
+ *      operating as an ldisc then we use this structure as our ldisc
+ *      state. We need to sort out lifetimes and locking with respect
+ *      to the gsm mux array. For now we don't free DLCI objects that
+ *      have been instantiated until the mux itself is terminated.
+ *
+ *      To consider further: tty open versus mux shutdown.
+ */
+struct gsm_mux {
+        struct tty_struct *tty;         /* The tty our ldisc is bound to */
+        spinlock_t lock;
+        /* Events on the GSM channel */
+        wait_queue_head_t event;
+        /* Bits for GSM mode decoding */
+        /* Framing Layer */
+        unsigned char *buf;
+        int state;
+#define GSM_SEARCH              0
+#define GSM_START               1
+#define GSM_ADDRESS             2
+#define GSM_CONTROL             3
+#define GSM_LEN                 4
+#define GSM_DATA                5
+#define GSM_FCS                 6
+#define GSM_OVERRUN             7
+        unsigned int len;
+        unsigned int address;
+        unsigned int count;
+        int escape;
+        int encoding;
+        u8 control;
+        u8 fcs;
+        u8 *txframe;                    /* TX framing buffer */
+        /* Methods for the receiver side */
+        void (*receive)(struct gsm_mux *gsm, u8 ch);
+        void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
+        /* And transmit side */
+        int (*output)(struct gsm_mux *mux, u8 *data, int len);
+        /* Link Layer */
+        unsigned int mru;
+        unsigned int mtu;
+        int initiator;                  /* Did we initiate connection */
+        int dead;                       /* Has the mux been shut down */
+        struct gsm_dlci *dlci[NUM_DLCI];
+        int constipated;                /* Asked by remote to shut up */
+        spinlock_t tx_lock;
+        unsigned int tx_bytes;          /* TX data outstanding */
+#define TX_THRESH_HI            8192
+#define TX_THRESH_LO            2048
+        struct gsm_msg *tx_head;        /* Pending data packets */
+        struct gsm_msg *tx_tail;
+        /* Control messages */
+        struct timer_list t2_timer;     /* Retransmit timer for commands */
+        int cretries;                   /* Command retry counter */
+        struct gsm_control *pending_cmd;/* Our current pending command */
+        spinlock_t control_lock;        /* Protects the pending command */
+        /* Configuration */
+        int adaption;           /* 1 or 2 supported */
+        u8 ftype;               /* UI or UIH */
+        int t1, t2;             /* Timers in 1/100th of a sec */
+        int n2;                 /* Retry count */
+        /* Statistics (not currently exposed) */
+        unsigned long bad_fcs;
+        unsigned long malformed;
+        unsigned long io_error;
+        unsigned long bad_size;
+        unsigned long unsupported;
+};
+/*
+ *      Mux objects - needed so that we can translate a tty index into the
+ *      relevant mux and DLCI.
+ */
+#define MAX_MUX         4                       /* 256 minors */
+static struct gsm_mux *gsm_mux[MAX_MUX];        /* GSM muxes */
+static spinlock_t gsm_mux_lock;
+/*
+ *      This section of the driver logic implements the GSM encodings
+ *      both the basic and the 'advanced'. Reliable transport is not
+ *      supported.
+ */
+#define CR                      0x02
+#define EA                      0x01
+#define PF                      0x10
+/* I is special: the rest are ..*/
+#define RR                      0x01
+#define UI                      0x03
+#define RNR                     0x05
+#define REJ                     0x09
+#define DM                      0x0F
+#define SABM                    0x2F
+#define DISC                    0x43
+#define UA                      0x63
+#define UIH                     0xEF
+/* Channel commands */
+#define CMD_NSC                 0x09
+#define CMD_TEST                0x11
+#define CMD_PSC                 0x21
+#define CMD_RLS                 0x29
+#define CMD_FCOFF               0x31
+#define CMD_PN                  0x41
+#define CMD_RPN                 0x49
+#define CMD_FCON                0x51
+#define CMD_CLD                 0x61
+#define CMD_SNC                 0x69
+#define CMD_MSC                 0x71
+/* Virtual modem bits */
+#define MDM_FC                  0x01
+#define MDM_RTC                 0x02
+#define MDM_RTR                 0x04
+#define MDM_IC                  0x20
+#define MDM_DV                  0x40
+#define GSM0_SOF                0xF9
+#define GSM1_SOF                0x7E
+#define GSM1_ESCAPE             0x7D
+#define GSM1_ESCAPE_BITS        0x20
+#define XON                     0x11
+#define XOFF                    0x13
+static const struct tty_port_operations gsm_port_ops;
+/*
+ *      CRC table for GSM 0710
+ */
+static const u8 gsm_fcs8[256] = {
+        0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
+        0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
+        0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
+        0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
+        0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
+        0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
+        0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
+        0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
+        0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
+        0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
+        0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
+        0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
+        0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
+        0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
+        0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
+        0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
+        0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
+        0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
+        0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
+        0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
+        0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
+        0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
+        0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
+        0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
+        0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
+        0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
+        0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
+        0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
+        0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
+        0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
+        0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
+        0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
+};
+#define INIT_FCS        0xFF
+#define GOOD_FCS        0xCF
+/**
+ *      gsm_fcs_add     -       update FCS
+ *      @fcs: Current FCS
+ *      @c: Next data
+ *
+ *      Update the FCS to include c. Uses the algorithm in the specification
+ *      notes.
+ */
+static inline u8 gsm_fcs_add(u8 fcs, u8 c)
+{
+        return gsm_fcs8[fcs ^ c];
+}
+/**
+ *      gsm_fcs_add_block       -       update FCS for a block
+ *      @fcs: Current FCS
+ *      @c: buffer of data
+ *      @len: length of buffer
+ *
+ *      Update the FCS to include c. Uses the algorithm in the specification
+ *      notes.
+ */
+static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
+{
+        while (len--)
+                fcs = gsm_fcs8[fcs ^ *c++];
+        return fcs;
+}
+/**
+ *      gsm_read_ea             -       read a byte into an EA
+ *      @val: variable holding value
+ *      c: byte going into the EA
+ *
+ *      Processes one byte of an EA. Updates the passed variable
+ *      and returns 1 if the EA is now completely read
+ */
+static int gsm_read_ea(unsigned int *val, u8 c)
+{
+        /* Add the next 7 bits into the value */
+        *val <<= 7;
+        *val |= c >> 1;
+        /* Was this the last byte of the EA 1 = yes*/
+        return c & EA;
+}
+/**
+ *      gsm_encode_modem        -       encode modem data bits
+ *      @dlci: DLCI to encode from
+ *
+ *      Returns the correct GSM encoded modem status bits (6 bit field) for
+ *      the current status of the DLCI and attached tty object
+ */
+static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
+{
+        u8 modembits = 0;
+        /* FC is true flow control not modem bits */
+        if (dlci->throttled)
+                modembits |= MDM_FC;
+        if (dlci->modem_tx & TIOCM_DTR)
+                modembits |= MDM_RTC;
+        if (dlci->modem_tx & TIOCM_RTS)
+                modembits |= MDM_RTR;
+        if (dlci->modem_tx & TIOCM_RI)
+                modembits |= MDM_IC;
+        if (dlci->modem_tx & TIOCM_CD)
+                modembits |= MDM_DV;
+        return modembits;
+}
+/**
+ *      gsm_print_packet        -       display a frame for debug
+ *      @hdr: header to print before decode
+ *      @addr: address EA from the frame
+ *      @cr: C/R bit from the frame
+ *      @control: control including PF bit
+ *      @data: following data bytes
+ *      @dlen: length of data
+ *
+ *      Displays a packet in human readable format for debugging purposes. The
+ *      style is based on amateur radio LAP-B dump display.
+ */
+static void gsm_print_packet(const char *hdr, int addr, int cr,
+                                        u8 control, const u8 *data, int dlen)
+{
+        if (!(debug & 1))
+                return;
+        printk(KERN_INFO "%s %d) %c: ", hdr, addr, "RC"[cr]);
+        switch (control & ~PF) {
+        case SABM:
+                printk(KERN_CONT "SABM");
+                break;
+        case UA:
+                printk(KERN_CONT "UA");
+                break;
+        case DISC:
+                printk(KERN_CONT "DISC");
+                break;
+        case DM:
+                printk(KERN_CONT "DM");
+                break;
+        case UI:
+                printk(KERN_CONT "UI");
+                break;
+        case UIH:
+                printk(KERN_CONT "UIH");
+                break;
+        default:
+                if (!(control & 0x01)) {
+                        printk(KERN_CONT "I N(S)%d N(R)%d",
+                                (control & 0x0E) >> 1, (control & 0xE)>> 5);
+                } else switch (control & 0x0F) {
+                case RR:
+                        printk("RR(%d)", (control & 0xE0) >> 5);
+                        break;
+                case RNR:
+                        printk("RNR(%d)", (control & 0xE0) >> 5);
+                        break;
+                case REJ:
+                        printk("REJ(%d)", (control & 0xE0) >> 5);
+                        break;
+                default:
+                        printk(KERN_CONT "[%02X]", control);
+                }
+        }
+        if (control & PF)
+                printk(KERN_CONT "(P)");
+        else
+                printk(KERN_CONT "(F)");
+        if (dlen) {
+                int ct = 0;
+                while (dlen--) {
+                        if (ct % 8 == 0)
+                                printk(KERN_CONT "\n    ");
+                        printk(KERN_CONT "%02X ", *data++);
+                        ct++;
+                }
+        }
+        printk(KERN_CONT "\n");
+}
+/*
+ *      Link level transmission side
+ */
+/**
+ *      gsm_stuff_packet        -       bytestuff a packet
+ *      @ibuf: input
+ *      @obuf: output
+ *      @len: length of input
+ *
+ *      Expand a buffer by bytestuffing it. The worst case size change
+ *      is doubling and the caller is responsible for handing out
+ *      suitable sized buffers.
+ */
+static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
+{
+        int olen = 0;
+        while (len--) {
+                if (*input == GSM1_SOF || *input == GSM1_ESCAPE
+                    || *input == XON || *input == XOFF) {
+                        *output++ = GSM1_ESCAPE;
+                        *output++ = *input++ ^ GSM1_ESCAPE_BITS;
+                        olen++;
+                } else
+                        *output++ = *input++;
+                olen++;
+        }
+        return olen;
+}
+static void hex_packet(const unsigned char *p, int len)
+{
+        int i;
+        for (i = 0; i < len; i++) {
+                if (i && (i % 16) == 0)
+                        printk("\n");
+                printk("%02X ", *p++);
+        }
+        printk("\n");
+}
+/**
+ *      gsm_send        -       send a control frame
+ *      @gsm: our GSM mux
+ *      @addr: address for control frame
+ *      @cr: command/response bit
+ *      @control:  control byte including PF bit
+ *
+ *      Format up and transmit a control frame. These do not go via the
+ *      queueing logic as they should be transmitted ahead of data when
+ *      they are needed.
+ *
+ *      FIXME: Lock versus data TX path
+ */
+static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
+{
+        int len;
+        u8 cbuf[10];
+        u8 ibuf[3];
+        switch (gsm->encoding) {
+        case 0:
+                cbuf[0] = GSM0_SOF;
+                cbuf[1] = (addr << 2) | (cr << 1) | EA;
+                cbuf[2] = control;
+                cbuf[3] = EA;   /* Length of data = 0 */
+                cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
+                cbuf[5] = GSM0_SOF;
+                len = 6;
+                break;
+        case 1:
+        case 2:
+                /* Control frame + packing (but not frame stuffing) in mode 1 */
+                ibuf[0] = (addr << 2) | (cr << 1) | EA;
+                ibuf[1] = control;
+                ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
+                /* Stuffing may double the size worst case */
+                len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
+                /* Now add the SOF markers */
+                cbuf[0] = GSM1_SOF;
+                cbuf[len + 1] = GSM1_SOF;
+                /* FIXME: we can omit the lead one in many cases */
+                len += 2;
+                break;
+        default:
+                WARN_ON(1);
+                return;
+        }
+        gsm->output(gsm, cbuf, len);
+        gsm_print_packet("-->", addr, cr, control, NULL, 0);
+}
+/**
+ *      gsm_response    -       send a control response
+ *      @gsm: our GSM mux
+ *      @addr: address for control frame
+ *      @control:  control byte including PF bit
+ *
+ *      Format up and transmit a link level response frame.
+ */
+static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
+{
+        gsm_send(gsm, addr, 0, control);
+}
+/**
+ *      gsm_command     -       send a control command
+ *      @gsm: our GSM mux
+ *      @addr: address for control frame
+ *      @control:  control byte including PF bit
+ *
+ *      Format up and transmit a link level command frame.
+ */
+static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
+{
+        gsm_send(gsm, addr, 1, control);
+}
+/* Data transmission */
+#define HDR_LEN         6       /* ADDR CTRL [LEN.2] DATA FCS */
+/**
+ *      gsm_data_alloc          -       allocate data frame
+ *      @gsm: GSM mux
+ *      @addr: DLCI address
+ *      @len: length excluding header and FCS
+ *      @ctrl: control byte
+ *
+ *      Allocate a new data buffer for sending frames with data. Space is left
+ *      at the front for header bytes but that is treated as an implementation
+ *      detail and not for the high level code to use
+ */
+static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
+                                                                u8 ctrl)
+{
+        struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
+                                                                GFP_ATOMIC);
+        if (m == NULL)
+                return NULL;
+        m->data = m->buffer + HDR_LEN - 1;      /* Allow for FCS */
+        m->len = len;
+        m->addr = addr;
+        m->ctrl = ctrl;
+        m->next = NULL;
+        return m;
+}
+/**
+ *      gsm_data_kick           -       poke the queue
+ *      @gsm: GSM Mux
+ *
+ *      The tty device has called us to indicate that room has appeared in
+ *      the transmit queue. Ram more data into the pipe if we have any
+ *
+ *      FIXME: lock against link layer control transmissions
+ */
+static void gsm_data_kick(struct gsm_mux *gsm)
+{
+        struct gsm_msg *msg = gsm->tx_head;
+        int len;
+        int skip_sof = 0;
+        /* FIXME: We need to apply this solely to data messages */
+        if (gsm->constipated)
+                return;
+        while (gsm->tx_head != NULL) {
+                msg = gsm->tx_head;
+                if (gsm->encoding != 0) {
+                        gsm->txframe[0] = GSM1_SOF;
+                        len = gsm_stuff_frame(msg->data,
+                                                gsm->txframe + 1, msg->len);
+                        gsm->txframe[len + 1] = GSM1_SOF;
+                        len += 2;
+                } else {
+                        gsm->txframe[0] = GSM0_SOF;
+                        memcpy(gsm->txframe + 1 , msg->data, msg->len);
+                        gsm->txframe[msg->len + 1] = GSM0_SOF;
+                        len = msg->len + 2;
+                }
+                if (debug & 4) {
+                        printk("gsm_data_kick: \n");
+                        hex_packet(gsm->txframe, len);
+                }
+                if (gsm->output(gsm, gsm->txframe + skip_sof,
+                                                len - skip_sof) < 0)
+                        break;
+                /* FIXME: Can eliminate one SOF in many more cases */
+                gsm->tx_head = msg->next;
+                if (gsm->tx_head == NULL)
+                        gsm->tx_tail = NULL;
+                gsm->tx_bytes -= msg->len;
+                kfree(msg);
+                /* For a burst of frames skip the extra SOF within the
+                   burst */
+                skip_sof = 1;
+        }
+}
+/**
+ *      __gsm_data_queue                -       queue a UI or UIH frame
+ *      @dlci: DLCI sending the data
+ *      @msg: message queued
+ *
+ *      Add data to the transmit queue and try and get stuff moving
+ *      out of the mux tty if not already doing so. The Caller must hold
+ *      the gsm tx lock.
+ */
+static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
+{
+        struct gsm_mux *gsm = dlci->gsm;
+        u8 *dp = msg->data;
+        u8 *fcs = dp + msg->len;
+        /* Fill in the header */
+        if (gsm->encoding == 0) {
+                if (msg->len < 128)
+                        *--dp = (msg->len << 1) | EA;
+                else {
+                        *--dp = (msg->len >> 6) | EA;
+                        *--dp = (msg->len & 127) << 1;
+                }
+        }
+        *--dp = msg->ctrl;
+        if (gsm->initiator)
+                *--dp = (msg->addr << 2) | 2 | EA;
+        else
+                *--dp = (msg->addr << 2) | EA;
+        *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
+        /* Ugly protocol layering violation */
+        if (msg->ctrl == UI || msg->ctrl == (UI|PF))
+                *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
+        *fcs = 0xFF - *fcs;
+        gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
+                                                        msg->data, msg->len);
+        /* Move the header back and adjust the length, also allow for the FCS
+           now tacked on the end */
+        msg->len += (msg->data - dp) + 1;
+        msg->data = dp;
+        /* Add to the actual output queue */
+        if (gsm->tx_tail)
+                gsm->tx_tail->next = msg;
+        else
+                gsm->tx_head = msg;
+        gsm->tx_tail = msg;
+        gsm->tx_bytes += msg->len;
+        gsm_data_kick(gsm);
+}
+/**
+ *      gsm_data_queue          -       queue a UI or UIH frame
+ *      @dlci: DLCI sending the data
+ *      @msg: message queued
+ *
+ *      Add data to the transmit queue and try and get stuff moving
+ *      out of the mux tty if not already doing so. Take the
+ *      the gsm tx lock and dlci lock.
+ */
+static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
+        __gsm_data_queue(dlci, msg);
+        spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
+}
+/**
+ *      gsm_dlci_data_output    -       try and push data out of a DLCI
+ *      @gsm: mux
+ *      @dlci: the DLCI to pull data from
+ *
+ *      Pull data from a DLCI and send it into the transmit queue if there
+ *      is data. Keep to the MRU of the mux. This path handles the usual tty
+ *      interface which is a byte stream with optional modem data.
+ *
+ *      Caller must hold the tx_lock of the mux.
+ */
+static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
+{
+        struct gsm_msg *msg;
+        u8 *dp;
+        int len, size;
+        int h = dlci->adaption - 1;
+        len = kfifo_len(dlci->fifo);
+        if (len == 0)
+                return 0;
+        /* MTU/MRU count only the data bits */
+        if (len > gsm->mtu)
+                len = gsm->mtu;
+        size = len + h;
+        msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
+        /* FIXME: need a timer or something to kick this so it can't
+           get stuck with no work outstanding and no buffer free */
+        if (msg == NULL)
+                return -ENOMEM;
+        dp = msg->data;
+        switch (dlci->adaption) {
+        case 1: /* Unstructured */
+                break;
+        case 2: /* Unstructed with modem bits. Always one byte as we never
+                   send inline break data */
+                *dp += gsm_encode_modem(dlci);
+                len--;
+                break;
+        }
+        WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
+        __gsm_data_queue(dlci, msg);
+        /* Bytes of data we used up */
+        return size;
+}
+/**
+ *      gsm_dlci_data_output_framed  -  try and push data out of a DLCI
+ *      @gsm: mux
+ *      @dlci: the DLCI to pull data from
+ *
+ *      Pull data from a DLCI and send it into the transmit queue if there
+ *      is data. Keep to the MRU of the mux. This path handles framed data
+ *      queued as skbuffs to the DLCI.
+ *
+ *      Caller must hold the tx_lock of the mux.
+ */
+static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
+                                                struct gsm_dlci *dlci)
+{
+        struct gsm_msg *msg;
+        u8 *dp;
+        int len, size;
+        int last = 0, first = 0;
+        int overhead = 0;
+        /* One byte per frame is used for B/F flags */
+        if (dlci->adaption == 4)
+                overhead = 1;
+        /* dlci->skb is locked by tx_lock */
+        if (dlci->skb == NULL) {
+                dlci->skb = skb_dequeue(&dlci->skb_list);
+                if (dlci->skb == NULL)
+                        return 0;
+                first = 1;
+        }
+        len = dlci->skb->len + overhead;
+        /* MTU/MRU count only the data bits */
+        if (len > gsm->mtu) {
+                if (dlci->adaption == 3) {
+                        /* Over long frame, bin it */
+                        kfree_skb(dlci->skb);
+                        dlci->skb = NULL;
+                        return 0;
+                }
+                len = gsm->mtu;
+        } else
+                last = 1;
+        size = len + overhead;
+        msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
+        /* FIXME: need a timer or something to kick this so it can't
+           get stuck with no work outstanding and no buffer free */
+        if (msg == NULL)
+                return -ENOMEM;
+        dp = msg->data;
+        if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
+                /* Flag byte to carry the start/end info */
+                *dp++ = last << 7 | first << 6 | 1;     /* EA */
+                len--;
+        }
+        memcpy(dp, skb_pull(dlci->skb, len), len);
+        __gsm_data_queue(dlci, msg);
+        if (last)
+                dlci->skb = NULL;
+        return size;
+}
+/**
+ *      gsm_dlci_data_sweep             -       look for data to send
+ *      @gsm: the GSM mux
+ *
+ *      Sweep the GSM mux channels in priority order looking for ones with
+ *      data to send. We could do with optimising this scan a bit. We aim
+ *      to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
+ *      TX_THRESH_LO we get called again
+ *
+ *      FIXME: We should round robin between groups and in theory you can
+ *      renegotiate DLCI priorities with optional stuff. Needs optimising.
+ */
+static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
+{
+        int len;
+        /* Priority ordering: We should do priority with RR of the groups */
+        int i = 1;
+        unsigned long flags;
+        spin_lock_irqsave(&gsm->tx_lock, flags);
+        while (i < NUM_DLCI) {
+                struct gsm_dlci *dlci;
+                if (gsm->tx_bytes > TX_THRESH_HI)
+                        break;
+                dlci = gsm->dlci[i];
+                if (dlci == NULL || dlci->constipated) {
+                        i++;
+                        continue;
+                }
+                if (dlci->adaption < 3)
+                        len = gsm_dlci_data_output(gsm, dlci);
+                else
+                        len = gsm_dlci_data_output_framed(gsm, dlci);
+                if (len < 0)
+                        return;
+                /* DLCI empty - try the next */
+                if (len == 0)
+                        i++;
+        }
+        spin_unlock_irqrestore(&gsm->tx_lock, flags);
+}
+/**
+ *      gsm_dlci_data_kick      -       transmit if possible
+ *      @dlci: DLCI to kick
+ *
+ *      Transmit data from this DLCI if the queue is empty. We can't rely on
+ *      a tty wakeup except when we filled the pipe so we need to fire off
+ *      new data ourselves in other cases.
+ */
+static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
+        /* If we have nothing running then we need to fire up */
+        if (dlci->gsm->tx_bytes == 0)
+                gsm_dlci_data_output(dlci->gsm, dlci);
+        else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
+                gsm_dlci_data_sweep(dlci->gsm);
+        spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
+}
+/*
+ *      Control message processing
+ */
+/**
+ *      gsm_control_reply       -       send a response frame to a control
+ *      @gsm: gsm channel
+ *      @cmd: the command to use
+ *      @data: data to follow encoded info
+ *      @dlen: length of data
+ *
+ *      Encode up and queue a UI/UIH frame containing our response.
+ */
+static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
+                                        int dlen)
+{
+        struct gsm_msg *msg;
+        msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
+        msg->data[0] = (cmd & 0xFE) << 1 | EA;  /* Clear C/R */
+        msg->data[1] = (dlen << 1) | EA;
+        memcpy(msg->data + 2, data, dlen);
+        gsm_data_queue(gsm->dlci[0], msg);
+}
+/**
+ *      gsm_process_modem       -       process received modem status
+ *      @tty: virtual tty bound to the DLCI
+ *      @dlci: DLCI to affect
+ *      @modem: modem bits (full EA)
+ *
+ *      Used when a modem control message or line state inline in adaption
+ *      layer 2 is processed. Sort out the local modem state and throttles
+ */
+static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
+                                                        u32 modem)
+{
+        int  mlines = 0;
+        u8 brk = modem >> 6;
+        /* Flow control/ready to communicate */
+        if (modem & MDM_FC) {
+                /* Need to throttle our output on this device */
+                dlci->constipated = 1;
+        }
+        if (modem & MDM_RTC) {
+                mlines |= TIOCM_DSR | TIOCM_DTR;
+                dlci->constipated = 0;
+                gsm_dlci_data_kick(dlci);
+        }
+        /* Map modem bits */
+        if (modem & MDM_RTR)
+                mlines |= TIOCM_RTS | TIOCM_CTS;
+        if (modem & MDM_IC)
+                mlines |= TIOCM_RI;
+        if (modem & MDM_DV)
+                mlines |= TIOCM_CD;
+        /* Carrier drop -> hangup */
+        if (tty) {
+                if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
+                        if (!(tty->termios->c_cflag & CLOCAL))
+                                tty_hangup(tty);
+                if (brk & 0x01)
+                        tty_insert_flip_char(tty, 0, TTY_BREAK);
+        }
+        dlci->modem_rx = mlines;
+}
+/**
+ *      gsm_control_modem       -       modem status received
+ *      @gsm: GSM channel
+ *      @data: data following command
+ *      @clen: command length
+ *
+ *      We have received a modem status control message. This is used by
+ *      the GSM mux protocol to pass virtual modem line status and optionally
+ *      to indicate break signals. Unpack it, convert to Linux representation
+ *      and if need be stuff a break message down the tty.
+ */
+static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
+{
+        unsigned int addr = 0;
+        unsigned int modem = 0;
+        struct gsm_dlci *dlci;
+        int len = clen;
+        u8 *dp = data;
+        struct tty_struct *tty;
+        while (gsm_read_ea(&addr, *dp++) == 0) {
+                len--;
+                if (len == 0)
+                        return;
+        }
+        /* Must be at least one byte following the EA */
+        len--;
+        if (len <= 0)
+                return;
+        addr >>= 1;
+        /* Closed port, or invalid ? */
+        if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
+                return;
+        dlci = gsm->dlci[addr];
+        while (gsm_read_ea(&modem, *dp++) == 0) {
+                len--;
+                if (len == 0)
+                        return;
+        }
+        tty = tty_port_tty_get(&dlci->port);
+        gsm_process_modem(tty, dlci, modem);
+        if (tty) {
+                tty_wakeup(tty);
+                tty_kref_put(tty);
+        }
+        gsm_control_reply(gsm, CMD_MSC, data, clen);
+}
+/**
+ *      gsm_control_rls         -       remote line status
+ *      @gsm: GSM channel
+ *      @data: data bytes
+ *      @clen: data length
+ *
+ *      The modem sends us a two byte message on the control channel whenever
+ *      it wishes to send us an error state from the virtual link. Stuff
+ *      this into the uplink tty if present
+ */
+static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
+{
+        struct tty_struct *tty;
+        unsigned int addr = 0 ;
+        u8 bits;
+        int len = clen;
+        u8 *dp = data;
+        while (gsm_read_ea(&addr, *dp++) == 0) {
+                len--;
+                if (len == 0)
+                        return;
+        }
+        /* Must be at least one byte following ea */
+        len--;
+        if (len <= 0)
+                return;
+        addr >>= 1;
+        /* Closed port, or invalid ? */
+        if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
+                return;
+        /* No error ? */
+        bits = *dp;
+        if ((bits & 1) == 0)
+                return;
+        /* See if we have an uplink tty */
+        tty = tty_port_tty_get(&gsm->dlci[addr]->port);
+        if (tty) {
+                if (bits & 2)
+                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                if (bits & 4)
+                        tty_insert_flip_char(tty, 0, TTY_PARITY);
+                if (bits & 8)
+                        tty_insert_flip_char(tty, 0, TTY_FRAME);
+                tty_flip_buffer_push(tty);
+                tty_kref_put(tty);
+        }
+        gsm_control_reply(gsm, CMD_RLS, data, clen);
+}
+static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
+/**
+ *      gsm_control_message     -       DLCI 0 control processing
+ *      @gsm: our GSM mux
+ *      @command:  the command EA
+ *      @data: data beyond the command/length EAs
+ *      @clen: length
+ *
+ *      Input processor for control messages from the other end of the link.
+ *      Processes the incoming request and queues a response frame or an
+ *      NSC response if not supported
+ */
+static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
+                                                        u8 *data, int clen)
+{
+        u8 buf[1];
+        switch (command) {
+        case CMD_CLD: {
+                struct gsm_dlci *dlci = gsm->dlci[0];
+                /* Modem wishes to close down */
+                if (dlci) {
+                        dlci->dead = 1;
+                        gsm->dead = 1;
+                        gsm_dlci_begin_close(dlci);
+                }
+                }
+                break;
+        case CMD_TEST:
+                /* Modem wishes to test, reply with the data */
+                gsm_control_reply(gsm, CMD_TEST, data, clen);
+                break;
+        case CMD_FCON:
+                /* Modem wants us to STFU */
+                gsm->constipated = 1;
+                gsm_control_reply(gsm, CMD_FCON, NULL, 0);
+                break;
+        case CMD_FCOFF:
+                /* Modem can accept data again */
+                gsm->constipated = 0;
+                gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
+                /* Kick the link in case it is idling */
+                gsm_data_kick(gsm);
+                break;
+        case CMD_MSC:
+                /* Out of band modem line change indicator for a DLCI */
+                gsm_control_modem(gsm, data, clen);
+                break;
+        case CMD_RLS:
+                /* Out of band error reception for a DLCI */
+                gsm_control_rls(gsm, data, clen);
+                break;
+        case CMD_PSC:
+                /* Modem wishes to enter power saving state */
+                gsm_control_reply(gsm, CMD_PSC, NULL, 0);
+                break;
+                /* Optional unsupported commands */
+        case CMD_PN:    /* Parameter negotiation */
+        case CMD_RPN:   /* Remote port negotation */
+        case CMD_SNC:   /* Service negotation command */
+        default:
+                /* Reply to bad commands with an NSC */
+                buf[0] = command;
+                gsm_control_reply(gsm, CMD_NSC, buf, 1);
+                break;
+        }
+}
+/**
+ *      gsm_control_response    -       process a response to our control
+ *      @gsm: our GSM mux
+ *      @command: the command (response) EA
+ *      @data: data beyond the command/length EA
+ *      @clen: length
+ *
+ *      Process a response to an outstanding command. We only allow a single
+ *      control message in flight so this is fairly easy. All the clean up
+ *      is done by the caller, we just update the fields, flag it as done
+ *      and return
+ */
+static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
+                                                        u8 *data, int clen)
+{
+        struct gsm_control *ctrl;
+        unsigned long flags;
+        spin_lock_irqsave(&gsm->control_lock, flags);
+        ctrl = gsm->pending_cmd;
+        /* Does the reply match our command */
+        command |= 1;
+        if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
+                /* Our command was replied to, kill the retry timer */
+                del_timer(&gsm->t2_timer);
+                gsm->pending_cmd = NULL;
+                /* Rejected by the other end */
+                if (command == CMD_NSC)
+                        ctrl->error = -EOPNOTSUPP;
+                ctrl->done = 1;
+                wake_up(&gsm->event);
+        }
+        spin_unlock_irqrestore(&gsm->control_lock, flags);
+}
+/**
+ *      gsm_control_transmit    -       send control packet
+ *      @gsm: gsm mux
+ *      @ctrl: frame to send
+ *
+ *      Send out a pending control command (called under control lock)
+ */
+static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
+{
+        struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1,
+                                                        gsm->ftype|PF);
+        if (msg == NULL)
+                return;
+        msg->data[0] = (ctrl->cmd << 1) | 2 | EA;       /* command */
+        memcpy(msg->data + 1, ctrl->data, ctrl->len);
+        gsm_data_queue(gsm->dlci[0], msg);
+}
+/**
+ *      gsm_control_retransmit  -       retransmit a control frame
+ *      @data: pointer to our gsm object
+ *
+ *      Called off the T2 timer expiry in order to retransmit control frames
+ *      that have been lost in the system somewhere. The control_lock protects
+ *      us from colliding with another sender or a receive completion event.
+ *      In that situation the timer may still occur in a small window but
+ *      gsm->pending_cmd will be NULL and we just let the timer expire.
+ */
+static void gsm_control_retransmit(unsigned long data)
+{
+        struct gsm_mux *gsm = (struct gsm_mux *)data;
+        struct gsm_control *ctrl;
+        unsigned long flags;
+        spin_lock_irqsave(&gsm->control_lock, flags);
+        ctrl = gsm->pending_cmd;
+        if (ctrl) {
+                gsm->cretries--;
+                if (gsm->cretries == 0) {
+                        gsm->pending_cmd = NULL;
+                        ctrl->error = -ETIMEDOUT;
+                        ctrl->done = 1;
+                        spin_unlock_irqrestore(&gsm->control_lock, flags);
+                        wake_up(&gsm->event);
+                        return;
+                }
+                gsm_control_transmit(gsm, ctrl);
+                mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
+        }
+        spin_unlock_irqrestore(&gsm->control_lock, flags);
+}
+/**
+ *      gsm_control_send        -       send a control frame on DLCI 0
+ *      @gsm: the GSM channel
+ *      @command: command  to send including CR bit
+ *      @data: bytes of data (must be kmalloced)
+ *      @len: length of the block to send
+ *
+ *      Queue and dispatch a control command. Only one command can be
+ *      active at a time. In theory more can be outstanding but the matching
+ *      gets really complicated so for now stick to one outstanding.
+ */
+static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
+                unsigned int command, u8 *data, int clen)
+{
+        struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
+                                                GFP_KERNEL);
+        unsigned long flags;
+        if (ctrl == NULL)
+                return NULL;
+retry:
+        wait_event(gsm->event, gsm->pending_cmd == NULL);
+        spin_lock_irqsave(&gsm->control_lock, flags);
+        if (gsm->pending_cmd != NULL) {
+                spin_unlock_irqrestore(&gsm->control_lock, flags);
+                goto retry;
+        }
+        ctrl->cmd = command;
+        ctrl->data = data;
+        ctrl->len = clen;
+        gsm->pending_cmd = ctrl;
+        gsm->cretries = gsm->n2;
+        mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
+        gsm_control_transmit(gsm, ctrl);
+        spin_unlock_irqrestore(&gsm->control_lock, flags);
+        return ctrl;
+}
+/**
+ *      gsm_control_wait        -       wait for a control to finish
+ *      @gsm: GSM mux
+ *      @control: control we are waiting on
+ *
+ *      Waits for the control to complete or time out. Frees any used
+ *      resources and returns 0 for success, or an error if the remote
+ *      rejected or ignored the request.
+ */
+static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
+{
+        int err;
+        wait_event(gsm->event, control->done == 1);
+        err = control->error;
+        kfree(control);
+        return err;
+}
+/*
+ *      DLCI level handling: Needs krefs
+ */
+/*
+ *      State transitions and timers
+ */
+/**
+ *      gsm_dlci_close          -       a DLCI has closed
+ *      @dlci: DLCI that closed
+ *
+ *      Perform processing when moving a DLCI into closed state. If there
+ *      is an attached tty this is hung up
+ */
+static void gsm_dlci_close(struct gsm_dlci *dlci)
+{
+        del_timer(&dlci->t1);
+        if (debug & 8)
+                printk("DLCI %d goes closed.\n", dlci->addr);
+        dlci->state = DLCI_CLOSED;
+        if (dlci->addr != 0) {
+                struct tty_struct  *tty = tty_port_tty_get(&dlci->port);
+                if (tty) {
+                        tty_hangup(tty);
+                        tty_kref_put(tty);
+                }
+                kfifo_reset(dlci->fifo);
+        } else
+                dlci->gsm->dead = 1;
+        wake_up(&dlci->gsm->event);
+        /* A DLCI 0 close is a MUX termination so we need to kick that
+           back to userspace somehow */
+}
+/**
+ *      gsm_dlci_open           -       a DLCI has opened
+ *      @dlci: DLCI that opened
+ *
+ *      Perform processing when moving a DLCI into open state.
+ */
+static void gsm_dlci_open(struct gsm_dlci *dlci)
+{
+        /* Note that SABM UA .. SABM UA first UA lost can mean that we go
+           open -> open */
+        del_timer(&dlci->t1);
+        /* This will let a tty open continue */
+        dlci->state = DLCI_OPEN;
+        if (debug & 8)
+                printk("DLCI %d goes open.\n", dlci->addr);
+        wake_up(&dlci->gsm->event);
+}
+/**
+ *      gsm_dlci_t1             -       T1 timer expiry
+ *      @dlci: DLCI that opened
+ *
+ *      The T1 timer handles retransmits of control frames (essentially of
+ *      SABM and DISC). We resend the command until the retry count runs out
+ *      in which case an opening port goes back to closed and a closing port
+ *      is simply put into closed state (any further frames from the other
+ *      end will get a DM response)
+ */
+static void gsm_dlci_t1(unsigned long data)
+{
+        struct gsm_dlci *dlci = (struct gsm_dlci *)data;
+        struct gsm_mux *gsm = dlci->gsm;
+        switch (dlci->state) {
+        case DLCI_OPENING:
+                dlci->retries--;
+                if (dlci->retries) {
+                        gsm_command(dlci->gsm, dlci->addr, SABM|PF);
+                        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
+                } else
+                        gsm_dlci_close(dlci);
+                break;
+        case DLCI_CLOSING:
+                dlci->retries--;
+                if (dlci->retries) {
+                        gsm_command(dlci->gsm, dlci->addr, DISC|PF);
+                        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
+                } else
+                        gsm_dlci_close(dlci);
+                break;
+        }
+}
+/**
+ *      gsm_dlci_begin_open     -       start channel open procedure
+ *      @dlci: DLCI to open
+ *
+ *      Commence opening a DLCI from the Linux side. We issue SABM messages
+ *      to the modem which should then reply with a UA, at which point we
+ *      will move into open state. Opening is done asynchronously with retry
+ *      running off timers and the responses.
+ */
+static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
+{
+        struct gsm_mux *gsm = dlci->gsm;
+        if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
+                return;
+        dlci->retries = gsm->n2;
+        dlci->state = DLCI_OPENING;
+        gsm_command(dlci->gsm, dlci->addr, SABM|PF);
+        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
+}
+/**
+ *      gsm_dlci_begin_close    -       start channel open procedure
+ *      @dlci: DLCI to open
+ *
+ *      Commence closing a DLCI from the Linux side. We issue DISC messages
+ *      to the modem which should then reply with a UA, at which point we
+ *      will move into closed state. Closing is done asynchronously with retry
+ *      off timers. We may also receive a DM reply from the other end which
+ *      indicates the channel was already closed.
+ */
+static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
+{
+        struct gsm_mux *gsm = dlci->gsm;
+        if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
+                return;
+        dlci->retries = gsm->n2;
+        dlci->state = DLCI_CLOSING;
+        gsm_command(dlci->gsm, dlci->addr, DISC|PF);
+        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
+}
+/**
+ *      gsm_dlci_data           -       data arrived
+ *      @dlci: channel
+ *      @data: block of bytes received
+ *      @len: length of received block
+ *
+ *      A UI or UIH frame has arrived which contains data for a channel
+ *      other than the control channel. If the relevant virtual tty is
+ *      open we shovel the bits down it, if not we drop them.
+ */
+static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int len)
+{
+        /* krefs .. */
+        struct tty_port *port = &dlci->port;
+        struct tty_struct *tty = tty_port_tty_get(port);
+        unsigned int modem = 0;
+        if (debug & 16)
+                printk("%d bytes for tty %p\n", len, tty);
+        if (tty) {
+                switch (dlci->adaption)  {
+                        /* Unsupported types */
+                        /* Packetised interruptible data */
+                        case 4:
+                                break;
+                        /* Packetised uininterruptible voice/data */
+                        case 3:
+                                break;
+                        /* Asynchronous serial with line state in each frame */
+                        case 2:
+                                while (gsm_read_ea(&modem, *data++) == 0) {
+                                        len--;
+                                        if (len == 0)
+                                                return;
+                                }
+                                gsm_process_modem(tty, dlci, modem);
+                        /* Line state will go via DLCI 0 controls only */
+                        case 1:
+                        default:
+                                tty_insert_flip_string(tty, data, len);
+                                tty_flip_buffer_push(tty);
+                }
+                tty_kref_put(tty);
+        }
+}
+/**
+ *      gsm_dlci_control        -       data arrived on control channel
+ *      @dlci: channel
+ *      @data: block of bytes received
+ *      @len: length of received block
+ *
+ *      A UI or UIH frame has arrived which contains data for DLCI 0 the
+ *      control channel. This should contain a command EA followed by
+ *      control data bytes. The command EA contains a command/response bit
+ *      and we divide up the work accordingly.
+ */
+static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
+{
+        /* See what command is involved */
+        unsigned int command = 0;
+        while (len-- > 0) {
+                if (gsm_read_ea(&command, *data++) == 1) {
+                        int clen = *data++;
+                        len--;
+                        /* FIXME: this is properly an EA */
+                        clen >>= 1;
+                        /* Malformed command ? */
+                        if (clen > len)
+                                return;
+                        if (command & 1)
+                                gsm_control_message(dlci->gsm, command,
+                                                                data, clen);
+                        else
+                                gsm_control_response(dlci->gsm, command,
+                                                                data, clen);
+                        return;
+                }
+        }
+}
+/*
+ *      Allocate/Free DLCI channels
+ */
+/**
+ *      gsm_dlci_alloc          -       allocate a DLCI
+ *      @gsm: GSM mux
+ *      @addr: address of the DLCI
+ *
+ *      Allocate and install a new DLCI object into the GSM mux.
+ *
+ *      FIXME: review locking races
+ */
+static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
+{
+        struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
+        if (dlci == NULL)
+                return NULL;
+        spin_lock_init(&dlci->lock);
+        dlci->fifo = &dlci->_fifo;
+        if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
+                kfree(dlci);
+                return NULL;
+        }
+        skb_queue_head_init(&dlci->skb_list);
+        init_timer(&dlci->t1);
+        dlci->t1.function = gsm_dlci_t1;
+        dlci->t1.data = (unsigned long)dlci;
+        tty_port_init(&dlci->port);
+        dlci->port.ops = &gsm_port_ops;
+        dlci->gsm = gsm;
+        dlci->addr = addr;
+        dlci->adaption = gsm->adaption;
+        dlci->state = DLCI_CLOSED;
+        if (addr)
+                dlci->data = gsm_dlci_data;
+        else
+                dlci->data = gsm_dlci_command;
+        gsm->dlci[addr] = dlci;
+        return dlci;
+}
+/**
+ *      gsm_dlci_free           -       release DLCI
+ *      @dlci: DLCI to destroy
+ *
+ *      Free up a DLCI. Currently to keep the lifetime rules sane we only
+ *      clean up DLCI objects when the MUX closes rather than as the port
+ *      is closed down on both the tty and mux levels.
+ *
+ *      Can sleep.
+ */
+static void gsm_dlci_free(struct gsm_dlci *dlci)
+{
+        struct tty_struct *tty = tty_port_tty_get(&dlci->port);
+        if (tty) {
+                tty_vhangup(tty);
+                tty_kref_put(tty);
+        }
+        del_timer_sync(&dlci->t1);
+        dlci->gsm->dlci[dlci->addr] = NULL;
+        kfifo_free(dlci->fifo);
+        kfree(dlci);
+}
+/*
+ *      LAPBish link layer logic
+ */
+/**
+ *      gsm_queue               -       a GSM frame is ready to process
+ *      @gsm: pointer to our gsm mux
+ *
+ *      At this point in time a frame has arrived and been demangled from
+ *      the line encoding. All the differences between the encodings have
+ *      been handled below us and the frame is unpacked into the structures.
+ *      The fcs holds the header FCS but any data FCS must be added here.
+ */
+static void gsm_queue(struct gsm_mux *gsm)
+{
+        struct gsm_dlci *dlci;
+        u8 cr;
+        int address;
+        /* We have to sneak a look at the packet body to do the FCS.
+           A somewhat layering violation in the spec */
+        if ((gsm->control & ~PF) == UI)
+                gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
+        if (gsm->fcs != GOOD_FCS) {
+                gsm->bad_fcs++;
+                if (debug & 4)
+                        printk("BAD FCS %02x\n", gsm->fcs);
+                return;
+        }
+        address = gsm->address >> 1;
+        if (address >= NUM_DLCI)
+                goto invalid;
+        cr = gsm->address & 1;          /* C/R bit */
+        gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
+        cr ^= 1 - gsm->initiator;       /* Flip so 1 always means command */
+        dlci = gsm->dlci[address];
+        switch (gsm->control) {
+        case SABM|PF:
+                if (cr == 0)
+                        goto invalid;
+                if (dlci == NULL)
+                        dlci = gsm_dlci_alloc(gsm, address);
+                if (dlci == NULL)
+                        return;
+                if (dlci->dead)
+                        gsm_response(gsm, address, DM);
+                else {
+                        gsm_response(gsm, address, UA);
+                        gsm_dlci_open(dlci);
+                }
+                break;
+        case DISC|PF:
+                if (cr == 0)
+                        goto invalid;
+                if (dlci == NULL || dlci->state == DLCI_CLOSED) {
+                        gsm_response(gsm, address, DM);
+                        return;
+                }
+                /* Real close complete */
+                gsm_response(gsm, address, UA);
+                gsm_dlci_close(dlci);
+                break;
+        case UA:
+        case UA|PF:
+                if (cr == 0 || dlci == NULL)
+                        break;
+                switch (dlci->state) {
+                case DLCI_CLOSING:
+                        gsm_dlci_close(dlci);
+                        break;
+                case DLCI_OPENING:
+                        gsm_dlci_open(dlci);
+                        break;
+                }
+                break;
+        case DM:        /* DM can be valid unsolicited */
+        case DM|PF:
+                if (cr)
+                        goto invalid;
+                if (dlci == NULL)
+                        return;
+                gsm_dlci_close(dlci);
+                break;
+        case UI:
+        case UI|PF:
+        case UIH:
+        case UIH|PF:
+#if 0
+                if (cr)
+                        goto invalid;
+#endif
+                if (dlci == NULL || dlci->state != DLCI_OPEN) {
+                        gsm_command(gsm, address, DM|PF);
+                        return;
+                }
+                dlci->data(dlci, gsm->buf, gsm->len);
+                break;
+        default:
+                goto invalid;
+        }
+        return;
+invalid:
+        gsm->malformed++;
+        return;
+}
+/**
+ *      gsm0_receive    -       perform processing for non-transparency
+ *      @gsm: gsm data for this ldisc instance
+ *      @c: character
+ *
+ *      Receive bytes in gsm mode 0
+ */
+static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
+{
+        switch (gsm->state) {
+        case GSM_SEARCH:        /* SOF marker */
+                if (c == GSM0_SOF) {
+                        gsm->state = GSM_ADDRESS;
+                        gsm->address = 0;
+                        gsm->len = 0;
+                        gsm->fcs = INIT_FCS;
+                }
+                break;          /* Address EA */
+        case GSM_ADDRESS:
+                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
+                if (gsm_read_ea(&gsm->address, c))
+                        gsm->state = GSM_CONTROL;
+                break;
+        case GSM_CONTROL:       /* Control Byte */
+                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
+                gsm->control = c;
+                gsm->state = GSM_LEN;
+                break;
+        case GSM_LEN:           /* Length EA */
+                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
+                if (gsm_read_ea(&gsm->len, c)) {
+                        if (gsm->len > gsm->mru) {
+                                gsm->bad_size++;
+                                gsm->state = GSM_SEARCH;
+                                break;
+                        }
+                        gsm->count = 0;
+                        gsm->state = GSM_DATA;
+                }
+                break;
+        case GSM_DATA:          /* Data */
+                gsm->buf[gsm->count++] = c;
+                if (gsm->count == gsm->len)
+                        gsm->state = GSM_FCS;
+                break;
+        case GSM_FCS:           /* FCS follows the packet */
+                gsm->fcs = c;
+                gsm_queue(gsm);
+                /* And then back for the next frame */
+                gsm->state = GSM_SEARCH;
+                break;
+        }
+}
+/**
+ *      gsm0_receive    -       perform processing for non-transparency
+ *      @gsm: gsm data for this ldisc instance
+ *      @c: character
+ *
+ *      Receive bytes in mode 1 (Advanced option)
+ */
+static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
+{
+        if (c == GSM1_SOF) {
+                /* EOF is only valid in frame if we have got to the data state
+                   and received at least one byte (the FCS) */
+                if (gsm->state == GSM_DATA && gsm->count) {
+                        /* Extract the FCS */
+                        gsm->count--;
+                        gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
+                        gsm->len = gsm->count;
+                        gsm_queue(gsm);
+                        gsm->state  = GSM_START;
+                        return;
+                }
+                /* Any partial frame was a runt so go back to start */
+                if (gsm->state != GSM_START) {
+                        gsm->malformed++;
+                        gsm->state = GSM_START;
+                }
+                /* A SOF in GSM_START means we are still reading idling or
+                   framing bytes */
+                return;
+        }
+        if (c == GSM1_ESCAPE) {
+                gsm->escape = 1;
+                return;
+        }
+        /* Only an unescaped SOF gets us out of GSM search */
+        if (gsm->state == GSM_SEARCH)
+                return;
+        if (gsm->escape) {
+                c ^= GSM1_ESCAPE_BITS;
+                gsm->escape = 0;
+        }
+        switch (gsm->state) {
+        case GSM_START:         /* First byte after SOF */
+                gsm->address = 0;
+                gsm->state = GSM_ADDRESS;
+                gsm->fcs = INIT_FCS;
+                /* Drop through */
+        case GSM_ADDRESS:       /* Address continuation */
+                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
+                if (gsm_read_ea(&gsm->address, c))
+                        gsm->state = GSM_CONTROL;
+                break;
+        case GSM_CONTROL:       /* Control Byte */
+                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
+                gsm->control = c;
+                gsm->count = 0;
+                gsm->state = GSM_DATA;
+                break;
+        case GSM_DATA:          /* Data */
+                if (gsm->count > gsm->mru ) {   /* Allow one for the FCS */
+                        gsm->state = GSM_OVERRUN;
+                        gsm->bad_size++;
+                } else
+                        gsm->buf[gsm->count++] = c;
+                break;
+        case GSM_OVERRUN:       /* Over-long - eg a dropped SOF */
+                break;
+        }
+}
+/**
+ *      gsm_error               -       handle tty error
+ *      @gsm: ldisc data
+ *      @data: byte received (may be invalid)
+ *      @flag: error received
+ *
+ *      Handle an error in the receipt of data for a frame. Currently we just
+ *      go back to hunting for a SOF.
+ *
+ *      FIXME: better diagnostics ?
+ */
+static void gsm_error(struct gsm_mux *gsm,
+                                unsigned char data, unsigned char flag)
+{
+        gsm->state = GSM_SEARCH;
+        gsm->io_error++;
+}
+/**
+ *      gsm_cleanup_mux         -       generic GSM protocol cleanup
+ *      @gsm: our mux
+ *
+ *      Clean up the bits of the mux which are the same for all framing
+ *      protocols. Remove the mux from the mux table, stop all the timers
+ *      and then shut down each device hanging up the channels as we go.
+ */
+void gsm_cleanup_mux(struct gsm_mux *gsm)
+{
+        int i;
+        struct gsm_dlci *dlci = gsm->dlci[0];
+        struct gsm_msg *txq;
+        gsm->dead = 1;
+        spin_lock(&gsm_mux_lock);
+        for (i = 0; i < MAX_MUX; i++) {
+                if (gsm_mux[i] == gsm) {
+                        gsm_mux[i] = NULL;
+                        break;
+                }
+        }
+        spin_unlock(&gsm_mux_lock);
+        WARN_ON(i == MAX_MUX);
+        del_timer_sync(&gsm->t2_timer);
+        /* Now we are sure T2 has stopped */
+        if (dlci) {
+                dlci->dead = 1;
+                gsm_dlci_begin_close(dlci);
+                wait_event_interruptible(gsm->event,
+                                        dlci->state == DLCI_CLOSED);
+        }
+        /* Free up any link layer users */
+        for (i = 0; i < NUM_DLCI; i++)
+                if (gsm->dlci[i])
+                        gsm_dlci_free(gsm->dlci[i]);
+        /* Now wipe the queues */
+        for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
+                gsm->tx_head = txq->next;
+                kfree(txq);
+        }
+        gsm->tx_tail = NULL;
+}
+EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
+/**
+ *      gsm_activate_mux        -       generic GSM setup
+ *      @gsm: our mux
+ *
+ *      Set up the bits of the mux which are the same for all framing
+ *      protocols. Add the mux to the mux table so it can be opened and
+ *      finally kick off connecting to DLCI 0 on the modem.
+ */
+int gsm_activate_mux(struct gsm_mux *gsm)
+{
+        struct gsm_dlci *dlci;
+        int i = 0;
+        init_timer(&gsm->t2_timer);
+        gsm->t2_timer.function = gsm_control_retransmit;
+        gsm->t2_timer.data = (unsigned long)gsm;
+        init_waitqueue_head(&gsm->event);
+        spin_lock_init(&gsm->control_lock);
+        spin_lock_init(&gsm->tx_lock);
+        if (gsm->encoding == 0)
+                gsm->receive = gsm0_receive;
+        else
+                gsm->receive = gsm1_receive;
+        gsm->error = gsm_error;
+        spin_lock(&gsm_mux_lock);
+        for (i = 0; i < MAX_MUX; i++) {
+                if (gsm_mux[i] == NULL) {
+                        gsm_mux[i] = gsm;
+                        break;
+                }
+        }
+        spin_unlock(&gsm_mux_lock);
+        if (i == MAX_MUX)
+                return -EBUSY;
+        dlci = gsm_dlci_alloc(gsm, 0);
+        if (dlci == NULL)
+                return -ENOMEM;
+        gsm->dead = 0;          /* Tty opens are now permissible */
+        return 0;
+}
+EXPORT_SYMBOL_GPL(gsm_activate_mux);
+/**
+ *      gsm_free_mux            -       free up a mux
+ *      @mux: mux to free
+ *
+ *      Dispose of allocated resources for a dead mux. No refcounting
+ *      at present so the mux must be truely dead.
+ */
+void gsm_free_mux(struct gsm_mux *gsm)
+{
+        kfree(gsm->txframe);
+        kfree(gsm->buf);
+        kfree(gsm);
+}
+EXPORT_SYMBOL_GPL(gsm_free_mux);
+/**
+ *      gsm_alloc_mux           -       allocate a mux
+ *
+ *      Creates a new mux ready for activation.
+ */
+struct gsm_mux *gsm_alloc_mux(void)
+{
+        struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
+        if (gsm == NULL)
+                return NULL;
+        gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
+        if (gsm->buf == NULL) {
+                kfree(gsm);
+                return NULL;
+        }
+        gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
+        if (gsm->txframe == NULL) {
+                kfree(gsm->buf);
+                kfree(gsm);
+                return NULL;
+        }
+        spin_lock_init(&gsm->lock);
+        gsm->t1 = T1;
+        gsm->t2 = T2;
+        gsm->n2 = N2;
+        gsm->ftype = UIH;
+        gsm->initiator = 0;
+        gsm->adaption = 1;
+        gsm->encoding = 1;
+        gsm->mru = 64;  /* Default to encoding 1 so these should be 64 */
+        gsm->mtu = 64;
+        gsm->dead = 1;  /* Avoid early tty opens */
+        return gsm;
+}
+EXPORT_SYMBOL_GPL(gsm_alloc_mux);
+/**
+ *      gsmld_output            -       write to link
+ *      @gsm: our mux
+ *      @data: bytes to output
+ *      @len: size
+ *
+ *      Write a block of data from the GSM mux to the data channel. This
+ *      will eventually be serialized from above but at the moment isn't.
+ */
+static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
+{
+        if (tty_write_room(gsm->tty) < len) {
+                set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
+                return -ENOSPC;
+        }
+        if (debug & 4) {
+                printk("-->%d bytes out\n", len);
+                hex_packet(data, len);
+        }
+        gsm->tty->ops->write(gsm->tty, data, len);
+        return len;
+}
+/**
+ *      gsmld_attach_gsm        -       mode set up
+ *      @tty: our tty structure
+ *      @gsm: our mux
+ *
+ *      Set up the MUX for basic mode and commence connecting to the
+ *      modem. Currently called from the line discipline set up but
+ *      will need moving to an ioctl path.
+ */
+static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
+{
+        int ret;
+        gsm->tty = tty_kref_get(tty);
+        gsm->output = gsmld_output;
+        ret =  gsm_activate_mux(gsm);
+        if (ret != 0)
+                tty_kref_put(gsm->tty);
+        return ret;
+}
+/**
+ *      gsmld_detach_gsm        -       stop doing 0710 mux
+ *      @tty: tty atttached to the mux
+ *      @gsm: mux
+ *
+ *      Shutdown and then clean up the resources used by the line discipline
+ */
+static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
+{
+        WARN_ON(tty != gsm->tty);
+        gsm_cleanup_mux(gsm);
+        tty_kref_put(gsm->tty);
+        gsm->tty = NULL;
+}
+static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
+                              char *fp, int count)
+{
+        struct gsm_mux *gsm = tty->disc_data;
+        const unsigned char *dp;
+        char *f;
+        int i;
+        char buf[64];
+        char flags;
+        if (debug & 4) {
+                printk("Inbytes %dd\n", count);
+                hex_packet(cp, count);
+        }
+        for (i = count, dp = cp, f = fp; i; i--, dp++) {
+                flags = *f++;
+                switch (flags) {
+                case TTY_NORMAL:
+                        gsm->receive(gsm, *dp);
+                        break;
+                case TTY_OVERRUN:
+                case TTY_BREAK:
+                case TTY_PARITY:
+                case TTY_FRAME:
+                        gsm->error(gsm, *dp, flags);
+                        break;
+                default:
+                        printk(KERN_ERR "%s: unknown flag %d\n",
+                               tty_name(tty, buf), flags);
+                        break;
+                }
+        }
+        /* FASYNC if needed ? */
+        /* If clogged call tty_throttle(tty); */
+}
+/**
+ *      gsmld_chars_in_buffer   -       report available bytes
+ *      @tty: tty device
+ *
+ *      Report the number of characters buffered to be delivered to user
+ *      at this instant in time.
+ *
+ *      Locking: gsm lock
+ */
+static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
+{
+        return 0;
+}
+/**
+ *      gsmld_flush_buffer      -       clean input queue
+ *      @tty:   terminal device
+ *
+ *      Flush the input buffer. Called when the line discipline is
+ *      being closed, when the tty layer wants the buffer flushed (eg
+ *      at hangup).
+ */
+static void gsmld_flush_buffer(struct tty_struct *tty)
+{
+}
+/**
+ *      gsmld_close             -       close the ldisc for this tty
+ *      @tty: device
+ *
+ *      Called from the terminal layer when this line discipline is
+ *      being shut down, either because of a close or becsuse of a
+ *      discipline change. The function will not be called while other
+ *      ldisc methods are in progress.
+ */
+static void gsmld_close(struct tty_struct *tty)
+{
+        struct gsm_mux *gsm = tty->disc_data;
+        gsmld_detach_gsm(tty, gsm);
+        gsmld_flush_buffer(tty);
+        /* Do other clean up here */
+        gsm_free_mux(gsm);
+}
+/**
+ *      gsmld_open              -       open an ldisc
+ *      @tty: terminal to open
+ *
+ *      Called when this line discipline is being attached to the
+ *      terminal device. Can sleep. Called serialized so that no
+ *      other events will occur in parallel. No further open will occur
+ *      until a close.
+ */
+static int gsmld_open(struct tty_struct *tty)
+{
+        struct gsm_mux *gsm;
+        if (tty->ops->write == NULL)
+                return -EINVAL;
+        /* Attach our ldisc data */
+        gsm = gsm_alloc_mux();
+        if (gsm == NULL)
+                return -ENOMEM;
+        tty->disc_data = gsm;
+        tty->receive_room = 65536;
+        /* Attach the initial passive connection */
+        gsm->encoding = 1;
+        return gsmld_attach_gsm(tty, gsm);
+}
+/**
+ *      gsmld_write_wakeup      -       asynchronous I/O notifier
+ *      @tty: tty device
+ *
+ *      Required for the ptys, serial driver etc. since processes
+ *      that attach themselves to the master and rely on ASYNC
+ *      IO must be woken up
+ */
+static void gsmld_write_wakeup(struct tty_struct *tty)
+{
+        struct gsm_mux *gsm = tty->disc_data;
+        /* Queue poll */
+        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
+        gsm_data_kick(gsm);
+        if (gsm->tx_bytes < TX_THRESH_LO)
+                gsm_dlci_data_sweep(gsm);
+}
+/**
+ *      gsmld_read              -       read function for tty
+ *      @tty: tty device
+ *      @file: file object
+ *      @buf: userspace buffer pointer
+ *      @nr: size of I/O
+ *
+ *      Perform reads for the line discipline. We are guaranteed that the
+ *      line discipline will not be closed under us but we may get multiple
+ *      parallel readers and must handle this ourselves. We may also get
+ *      a hangup. Always called in user context, may sleep.
+ *
+ *      This code must be sure never to sleep through a hangup.
+ */
+static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
+                         unsigned char __user *buf, size_t nr)
+{
+        return -EOPNOTSUPP;
+}
+/**
+ *      gsmld_write             -       write function for tty
+ *      @tty: tty device
+ *      @file: file object
+ *      @buf: userspace buffer pointer
+ *      @nr: size of I/O
+ *
+ *      Called when the owner of the device wants to send a frame
+ *      itself (or some other control data). The data is transferred
+ *      as-is and must be properly framed and checksummed as appropriate
+ *      by userspace. Frames are either sent whole or not at all as this
+ *      avoids pain user side.
+ */
+static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
+                           const unsigned char *buf, size_t nr)
+{
+        int space = tty_write_room(tty);
+        if (space >= nr)
+                return tty->ops->write(tty, buf, nr);
+        set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
+        return -ENOBUFS;
+}
+/**
+ *      gsmld_poll              -       poll method for N_GSM0710
+ *      @tty: terminal device
+ *      @file: file accessing it
+ *      @wait: poll table
+ *
+ *      Called when the line discipline is asked to poll() for data or
+ *      for special events. This code is not serialized with respect to
+ *      other events save open/close.
+ *
+ *      This code must be sure never to sleep through a hangup.
+ *      Called without the kernel lock held - fine
+ */
+static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
+                                                        poll_table *wait)
+{
+        unsigned int mask = 0;
+        struct gsm_mux *gsm = tty->disc_data;
+        poll_wait(file, &tty->read_wait, wait);
+        poll_wait(file, &tty->write_wait, wait);
+        if (tty_hung_up_p(file))
+                mask |= POLLHUP;
+        if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
+                mask |= POLLOUT | POLLWRNORM;
+        if (gsm->dead)
+                mask |= POLLHUP;
+        return mask;
+}
+static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
+                                                        struct gsm_config *c)
+{
+        int need_close = 0;
+        int need_restart = 0;
+        /* Stuff we don't support yet - UI or I frame transport, windowing */
+        if ((c->adaption !=1 && c->adaption != 2) || c->k)
+                return -EOPNOTSUPP;
+        /* Check the MRU/MTU range looks sane */
+        if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
+                return -EINVAL;
+        if (c->n2 < 3)
+                return -EINVAL;
+        if (c->encapsulation > 1)       /* Basic, advanced, no I */
+                return -EINVAL;
+        if (c->initiator > 1)
+                return -EINVAL;
+        if (c->i == 0 || c->i > 2)      /* UIH and UI only */
+                return -EINVAL;
+        /*
+         *      See what is needed for reconfiguration
+         */
+        /* Timing fields */
+        if (c->t1 != 0 && c->t1 != gsm->t1)
+                need_restart = 1;
+        if (c->t2 != 0 && c->t2 != gsm->t2)
+                need_restart = 1;
+        if (c->encapsulation != gsm->encoding)
+                need_restart = 1;
+        if (c->adaption != gsm->adaption)
+                need_restart = 1;
+        /* Requires care */
+        if (c->initiator != gsm->initiator)
+                need_close = 1;
+        if (c->mru != gsm->mru)
+                need_restart = 1;
+        if (c->mtu != gsm->mtu)
+                need_restart = 1;
+        /*
+         *      Close down what is needed, restart and initiate the new
+         *      configuration
+         */
+        if (need_close || need_restart) {
+                gsm_dlci_begin_close(gsm->dlci[0]);
+                /* This will timeout if the link is down due to N2 expiring */
+                wait_event_interruptible(gsm->event,
+                                gsm->dlci[0]->state == DLCI_CLOSED);
+                if (signal_pending(current))
+                        return -EINTR;
+        }
+        if (need_restart)
+                gsm_cleanup_mux(gsm);
+        gsm->initiator = c->initiator;
+        gsm->mru = c->mru;
+        gsm->encoding = c->encapsulation;
+        gsm->adaption = c->adaption;
+        if (c->i == 1)
+                gsm->ftype = UIH;
+        else if (c->i == 2)
+                gsm->ftype = UI;
+        if (c->t1)
+                gsm->t1 = c->t1;
+        if (c->t2)
+                gsm->t2 = c->t2;
+        /* FIXME: We need to separate activation/deactivation from adding
+           and removing from the mux array */
+        if (need_restart)
+                gsm_activate_mux(gsm);
+        if (gsm->initiator && need_close)
+                gsm_dlci_begin_open(gsm->dlci[0]);
+        return 0;
+}
+static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
+                       unsigned int cmd, unsigned long arg)
+{
+        struct gsm_config c;
+        struct gsm_mux *gsm = tty->disc_data;
+        switch (cmd) {
+        case GSMIOC_GETCONF:
+                memset(&c, 0, sizeof(c));
+                c.adaption = gsm->adaption;
+                c.encapsulation = gsm->encoding;
+                c.initiator = gsm->initiator;
+                c.t1 = gsm->t1;
+                c.t2 = gsm->t2;
+                c.t3 = 0;       /* Not supported */
+                c.n2 = gsm->n2;
+                if (gsm->ftype == UIH)
+                        c.i = 1;
+                else
+                        c.i = 2;
+                printk("Ftype %d i %d\n", gsm->ftype, c.i);
+                c.mru = gsm->mru;
+                c.mtu = gsm->mtu;
+                c.k = 0;
+                if (copy_to_user((void *)arg, &c, sizeof(c)))
+                        return -EFAULT;
+                return 0;
+        case GSMIOC_SETCONF:
+                if (copy_from_user(&c, (void *)arg, sizeof(c)))
+                        return -EFAULT;
+                return gsmld_config(tty, gsm, &c);
+        default:
+                return n_tty_ioctl_helper(tty, file, cmd, arg);
+        }
+}
+/* Line discipline for real tty */
+struct tty_ldisc_ops tty_ldisc_packet = {
+        .owner           = THIS_MODULE,
+        .magic           = TTY_LDISC_MAGIC,
+        .name            = "n_gsm",
+        .open            = gsmld_open,
+        .close           = gsmld_close,
+        .flush_buffer    = gsmld_flush_buffer,
+        .chars_in_buffer = gsmld_chars_in_buffer,
+        .read            = gsmld_read,
+        .write           = gsmld_write,
+        .ioctl           = gsmld_ioctl,
+        .poll            = gsmld_poll,
+        .receive_buf     = gsmld_receive_buf,
+        .write_wakeup    = gsmld_write_wakeup
+};
+/*
+ *      Virtual tty side
+ */
+#define TX_SIZE         512
+static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
+{
+        u8 modembits[5];
+        struct gsm_control *ctrl;
+        int len = 2;
+        if (brk)
+                len++;
+        modembits[0] = len << 1 | EA;           /* Data bytes */
+        modembits[1] = dlci->addr << 2 | 3;     /* DLCI, EA, 1 */
+        modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
+        if (brk)
+                modembits[3] = brk << 4 | 2 | EA;       /* Valid, EA */
+        ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
+        if (ctrl == NULL)
+                return -ENOMEM;
+        return gsm_control_wait(dlci->gsm, ctrl);
+}
+static int gsm_carrier_raised(struct tty_port *port)
+{
+        struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
+        /* Not yet open so no carrier info */
+        if (dlci->state != DLCI_OPEN)
+                return 0;
+        if (debug & 2)
+                return 1;
+        return dlci->modem_rx & TIOCM_CD;
+}
+static void gsm_dtr_rts(struct tty_port *port, int onoff)
+{
+        struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
+        unsigned int modem_tx = dlci->modem_tx;
+        if (onoff)
+                modem_tx |= TIOCM_DTR | TIOCM_RTS;
+        else
+                modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
+        if (modem_tx != dlci->modem_tx) {
+                dlci->modem_tx = modem_tx;
+                gsmtty_modem_update(dlci, 0);
+        }
+}
+static const struct tty_port_operations gsm_port_ops = {
+        .carrier_raised = gsm_carrier_raised,
+        .dtr_rts = gsm_dtr_rts,
+};
+static int gsmtty_open(struct tty_struct *tty, struct file *filp)
+{
+        struct gsm_mux *gsm;
+        struct gsm_dlci *dlci;
+        struct tty_port *port;
+        unsigned int line = tty->index;
+        unsigned int mux = line >> 6;
+        line = line & 0x3F;
+        if (mux >= MAX_MUX)
+                return -ENXIO;
+        /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
+        if (gsm_mux[mux] == NULL)
+                return -EUNATCH;
+        if (line == 0 || line > 61)     /* 62/63 reserved */
+                return -ECHRNG;
+        gsm = gsm_mux[mux];
+        if (gsm->dead)
+                return -EL2HLT;
+        dlci = gsm->dlci[line];
+        if (dlci == NULL)
+                dlci = gsm_dlci_alloc(gsm, line);
+        if (dlci == NULL)
+                return -ENOMEM;
+        port = &dlci->port;
+        port->count++;
+        tty->driver_data = dlci;
+        tty_port_tty_set(port, tty);
+        dlci->modem_rx = 0;
+        /* We could in theory open and close before we wait - eg if we get
+           a DM straight back. This is ok as that will have caused a hangup */
+        set_bit(ASYNCB_INITIALIZED, &port->flags);
+        /* Start sending off SABM messages */
+        gsm_dlci_begin_open(dlci);
+        /* And wait for virtual carrier */
+        return tty_port_block_til_ready(port, tty, filp);
+}
+static void gsmtty_close(struct tty_struct *tty, struct file *filp)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        if (dlci == NULL)
+                return;
+        if (tty_port_close_start(&dlci->port, tty, filp) == 0)
+                return;
+        gsm_dlci_begin_close(dlci);
+        tty_port_close_end(&dlci->port, tty);
+        tty_port_tty_set(&dlci->port, NULL);
+}
+static void gsmtty_hangup(struct tty_struct *tty)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        tty_port_hangup(&dlci->port);
+        gsm_dlci_begin_close(dlci);
+}
+static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
+                                                                    int len)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        /* Stuff the bytes into the fifo queue */
+        int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
+        /* Need to kick the channel */
+        gsm_dlci_data_kick(dlci);
+        return sent;
+}
+static int gsmtty_write_room(struct tty_struct *tty)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        return TX_SIZE - kfifo_len(dlci->fifo);
+}
+static int gsmtty_chars_in_buffer(struct tty_struct *tty)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        return kfifo_len(dlci->fifo);
+}
+static void gsmtty_flush_buffer(struct tty_struct *tty)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        /* Caution needed: If we implement reliable transport classes
+           then the data being transmitted can't simply be junked once
+           it has first hit the stack. Until then we can just blow it
+           away */
+        kfifo_reset(dlci->fifo);
+        /* Need to unhook this DLCI from the transmit queue logic */
+}
+static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
+{
+        /* The FIFO handles the queue so the kernel will do the right
+           thing waiting on chars_in_buffer before calling us. No work
+           to do here */
+}
+static int gsmtty_tiocmget(struct tty_struct *tty, struct file *filp)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        return dlci->modem_rx;
+}
+static int gsmtty_tiocmset(struct tty_struct *tty, struct file *filp,
+        unsigned int set, unsigned int clear)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        unsigned int modem_tx = dlci->modem_tx;
+        modem_tx &= clear;
+        modem_tx |= set;
+        if (modem_tx != dlci->modem_tx) {
+                dlci->modem_tx = modem_tx;
+                return gsmtty_modem_update(dlci, 0);
+        }
+        return 0;
+}
+static int gsmtty_ioctl(struct tty_struct *tty, struct file *filp,
+                        unsigned int cmd, unsigned long arg)
+{
+        return -ENOIOCTLCMD;
+}
+static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
+{
+        /* For the moment its fixed. In actual fact the speed information
+           for the virtual channel can be propogated in both directions by
+           the RPN control message. This however rapidly gets nasty as we
+           then have to remap modem signals each way according to whether
+           our virtual cable is null modem etc .. */
+        tty_termios_copy_hw(tty->termios, old);
+}
+static void gsmtty_throttle(struct tty_struct *tty)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        if (tty->termios->c_cflag & CRTSCTS)
+                dlci->modem_tx &= ~TIOCM_DTR;
+        dlci->throttled = 1;
+        /* Send an MSC with DTR cleared */
+        gsmtty_modem_update(dlci, 0);
+}
+static void gsmtty_unthrottle(struct tty_struct *tty)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        if (tty->termios->c_cflag & CRTSCTS)
+                dlci->modem_tx |= TIOCM_DTR;
+        dlci->throttled = 0;
+        /* Send an MSC with DTR set */
+        gsmtty_modem_update(dlci, 0);
+}
+static int gsmtty_break_ctl(struct tty_struct *tty, int state)
+{
+        struct gsm_dlci *dlci = tty->driver_data;
+        int encode = 0; /* Off */
+        if (state == -1)        /* "On indefinitely" - we can't encode this
+                                    properly */
+                encode = 0x0F;
+        else if (state > 0) {
+                encode = state / 200;   /* mS to encoding */
+                if (encode > 0x0F)
+                        encode = 0x0F;  /* Best effort */
+        }
+        return gsmtty_modem_update(dlci, encode);
+}
+static struct tty_driver *gsm_tty_driver;
+/* Virtual ttys for the demux */
+static const struct tty_operations gsmtty_ops = {
+        .open                   = gsmtty_open,
+        .close                  = gsmtty_close,
+        .write                  = gsmtty_write,
+        .write_room             = gsmtty_write_room,
+        .chars_in_buffer        = gsmtty_chars_in_buffer,
+        .flush_buffer           = gsmtty_flush_buffer,
+        .ioctl                  = gsmtty_ioctl,
+        .throttle               = gsmtty_throttle,
+        .unthrottle             = gsmtty_unthrottle,
+        .set_termios            = gsmtty_set_termios,
+        .hangup                 = gsmtty_hangup,
+        .wait_until_sent        = gsmtty_wait_until_sent,
+        .tiocmget               = gsmtty_tiocmget,
+        .tiocmset               = gsmtty_tiocmset,
+        .break_ctl              = gsmtty_break_ctl,
+};
+static int __init gsm_init(void)
+{
+        /* Fill in our line protocol discipline, and register it */
+        int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
+        if (status != 0) {
+                printk(KERN_ERR "n_gsm: can't register line discipline (err = %d)\n", status);
+                return status;
+        }
+        gsm_tty_driver = alloc_tty_driver(256);
+        if (!gsm_tty_driver) {
+                tty_unregister_ldisc(N_GSM0710);
+                printk(KERN_ERR "gsm_init: tty allocation failed.\n");
+                return -EINVAL;
+        }
+        gsm_tty_driver->owner   = THIS_MODULE;
+        gsm_tty_driver->driver_name     = "gsmtty";
+        gsm_tty_driver->name            = "gsmtty";
+        gsm_tty_driver->major           = 0;    /* Dynamic */
+        gsm_tty_driver->minor_start     = 0;
+        gsm_tty_driver->type            = TTY_DRIVER_TYPE_SERIAL;
+        gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
+        gsm_tty_driver->flags   = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
+                                                        | TTY_DRIVER_HARDWARE_BREAK;
+        gsm_tty_driver->init_termios    = tty_std_termios;
+        /* Fixme */
+        gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
+        tty_set_operations(gsm_tty_driver, &gsmtty_ops);
+        spin_lock_init(&gsm_mux_lock);
+        if (tty_register_driver(gsm_tty_driver)) {
+                put_tty_driver(gsm_tty_driver);
+                tty_unregister_ldisc(N_GSM0710);
+                printk(KERN_ERR "gsm_init: tty registration failed.\n");
+                return -EBUSY;
+        }
+        printk(KERN_INFO "gsm_init: loaded as %d,%d.\n", gsm_tty_driver->major, gsm_tty_driver->minor_start);
+        return 0;
+}
+static void __exit gsm_exit(void)
+{
+        int status = tty_unregister_ldisc(N_GSM0710);
+        if (status != 0)
+                printk(KERN_ERR "n_gsm: can't unregister line discipline (err = %d)\n", status);
+        tty_unregister_driver(gsm_tty_driver);
+        put_tty_driver(gsm_tty_driver);
+        printk(KERN_INFO "gsm_init: unloaded.\n");
+}
+module_init(gsm_init);
+module_exit(gsm_exit);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_LDISC(N_GSM0710);
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index 78a62ebe75c7..ecbe479c7d68 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -176,23 +176,6 @@ static void config_setup(struct cyclades_port *);
 static void show_status(int);
 #endif
-#ifdef CONFIG_REMOTE_DEBUG
-static void debug_setup(void);
-void queueDebugChar(int c);
-int getDebugChar(void);
-#define DEBUG_PORT      1
-#define DEBUG_LEN       256
-typedef struct {
-        int in;
-        int out;
-        unsigned char buf[DEBUG_LEN];
-} debugq;
-debugq debugiq;
-#endif
 /*
 * I have my own version of udelay(), as it is needed when initialising
 * the chip, before the delay loop has been calibrated.  Should probably
@@ -515,11 +498,6 @@ static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
        /* determine the channel and change to that context */
        channel = (u_short) (base_addr[CyLICR] >> 2);
-#ifdef CONFIG_REMOTE_DEBUG
-        if (channel == DEBUG_PORT) {
-                panic("TxInt on debug port!!!");
-        }
-#endif
        /* validate the port number (as configured and open) */
        if ((channel < 0) || (NR_PORTS <= channel)) {
                base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
@@ -634,14 +612,6 @@ static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
        info->last_active = jiffies;
        save_cnt = char_count = base_addr[CyRFOC];
-#ifdef CONFIG_REMOTE_DEBUG
-        if (channel == DEBUG_PORT) {
-                while (char_count--) {
-                        data = base_addr[CyRDR];
-                        queueDebugChar(data);
-                }
-        } else
-#endif
                /* if there is nowhere to put the data, discard it */
        if (info->tty == 0) {
                while (char_count--) {
@@ -2195,9 +2165,7 @@ static int __init serial167_init(void)
                port_num++;
                info++;
        }
-#ifdef CONFIG_REMOTE_DEBUG
-        debug_setup();
-#endif
        ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0,
                          "cd2401_errors", cd2401_rxerr_interrupt);
        if (ret) {
@@ -2518,193 +2486,4 @@ static int __init serial167_console_init(void)
 console_initcall(serial167_console_init);
-#ifdef CONFIG_REMOTE_DEBUG
-void putDebugChar(int c)
-{
-        volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
-        unsigned long flags;
-        volatile u_char sink;
-        u_char ier;
-        int port;
-        local_irq_save(flags);
-        /* Ensure transmitter is enabled! */
-        port = DEBUG_PORT;
-        base_addr[CyCAR] = (u_char) port;
-        while (base_addr[CyCCR])
-                ;
-        base_addr[CyCCR] = CyENB_XMTR;
-        ier = base_addr[CyIER];
-        base_addr[CyIER] = CyTxMpty;
-        while (1) {
-                if (pcc2chip[PccSCCTICR] & 0x20) {
-                        /* We have a Tx int. Acknowledge it */
-                        sink = pcc2chip[PccTPIACKR];
-                        if ((base_addr[CyLICR] >> 2) == port) {
-                                base_addr[CyTDR] = c;
-                                base_addr[CyTEOIR] = 0;
-                                break;
-                        } else
-                                base_addr[CyTEOIR] = CyNOTRANS;
-                }
-        }
-        base_addr[CyIER] = ier;
-        local_irq_restore(flags);
-}
-int getDebugChar()
-{
-        volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
-        unsigned long flags;
-        volatile u_char sink;
-        u_char ier;
-        int port;
-        int i, c;
-        i = debugiq.out;
-        if (i != debugiq.in) {
-                c = debugiq.buf[i];
-                if (++i == DEBUG_LEN)
-                        i = 0;
-                debugiq.out = i;
-                return c;
-        }
-        /* OK, nothing in queue, wait in poll loop */
-        local_irq_save(flags);
-        /* Ensure receiver is enabled! */
-        port = DEBUG_PORT;
-        base_addr[CyCAR] = (u_char) port;
-#if 0
-        while (base_addr[CyCCR])
-                ;
-        base_addr[CyCCR] = CyENB_RCVR;
-#endif
-        ier = base_addr[CyIER];
-        base_addr[CyIER] = CyRxData;
-        while (1) {
-                if (pcc2chip[PccSCCRICR] & 0x20) {
-                        /* We have a Rx int. Acknowledge it */
-                        sink = pcc2chip[PccRPIACKR];
-                        if ((base_addr[CyLICR] >> 2) == port) {
-                                int cnt = base_addr[CyRFOC];
-                                while (cnt-- > 0) {
-                                        c = base_addr[CyRDR];
-                                        if (c == 0)
-                                                printk
-                                                    ("!! debug char is null (cnt=%d) !!",
-                                                     cnt);
-                                        else
-                                                queueDebugChar(c);
-                                }
-                                base_addr[CyREOIR] = 0;
-                                i = debugiq.out;
-                                if (i == debugiq.in)
-                                        panic("Debug input queue empty!");
-                                c = debugiq.buf[i];
-                                if (++i == DEBUG_LEN)
-                                        i = 0;
-                                debugiq.out = i;
-                                break;
-                        } else
-                                base_addr[CyREOIR] = CyNOTRANS;
-                }
-        }
-        base_addr[CyIER] = ier;
-        local_irq_restore(flags);
-        return (c);
-}
-void queueDebugChar(int c)
-{
-        int i;
-        i = debugiq.in;
-        debugiq.buf[i] = c;
-        if (++i == DEBUG_LEN)
-                i = 0;
-        if (i != debugiq.out)
-                debugiq.in = i;
-}
-static void debug_setup()
-{
-        unsigned long flags;
-        volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
-        int i, cflag;
-        cflag = B19200;
-        local_irq_save(flags);
-        for (i = 0; i < 4; i++) {
-                base_addr[CyCAR] = i;
-                base_addr[CyLICR] = i << 2;
-        }
-        debugiq.in = debugiq.out = 0;
-        base_addr[CyCAR] = DEBUG_PORT;
-        /* baud rate */
-        i = cflag & CBAUD;
-        base_addr[CyIER] = 0;
-        base_addr[CyCMR] = CyASYNC;
-        base_addr[CyLICR] = DEBUG_PORT << 2;
-        base_addr[CyLIVR] = 0x5c;
-        /* tx and rx baud rate */
-        base_addr[CyTCOR] = baud_co[i];
-        base_addr[CyTBPR] = baud_bpr[i];
-        base_addr[CyRCOR] = baud_co[i] >> 5;
-        base_addr[CyRBPR] = baud_bpr[i];
-        /* set line characteristics  according configuration */
-        base_addr[CySCHR1] = 0;
-        base_addr[CySCHR2] = 0;
-        base_addr[CySCRL] = 0;
-        base_addr[CySCRH] = 0;
-        base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
-        base_addr[CyCOR2] = 0;
-        base_addr[CyCOR3] = Cy_1_STOP;
-        base_addr[CyCOR4] = baud_cor4[i];
-        base_addr[CyCOR5] = 0;
-        base_addr[CyCOR6] = 0;
-        base_addr[CyCOR7] = 0;
-        write_cy_cmd(base_addr, CyINIT_CHAN);
-        write_cy_cmd(base_addr, CyENB_RCVR);
-        base_addr[CyCAR] = DEBUG_PORT;  /* !!! Is this needed? */
-        base_addr[CyRTPRL] = 2;
-        base_addr[CyRTPRH] = 0;
-        base_addr[CyMSVR1] = CyRTS;
-        base_addr[CyMSVR2] = CyDTR;
-        base_addr[CyIER] = CyRxData;
-        local_irq_restore(flags);
-}                               /* debug_setup */
-#endif
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tty_buffer.c b/drivers/char/tty_buffer.c
index 7ee52164d474..cc1e9850d655 100644
--- a/drivers/char/tty_buffer.c
+++ b/drivers/char/tty_buffer.c
@@ -238,7 +238,7 @@ EXPORT_SYMBOL_GPL(tty_buffer_request_room);
 *      @size: size
 *
 *      Queue a series of bytes to the tty buffering. All the characters
- *      passed are marked as without error. Returns the number added.
+ *      passed are marked with the supplied flag. Returns the number added.
 *
 *      Locking: Called functions may take tty->buf.lock
 */
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index fb09bb3c0ad6..aa9bc9e980e1 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -149,7 +149,7 @@ static ssize_t smi_data_buf_size_store(struct device *dev,
        return count;
 }
-static ssize_t smi_data_read(struct kobject *kobj,
+static ssize_t smi_data_read(struct file *filp, struct kobject *kobj,
                             struct bin_attribute *bin_attr,
                             char *buf, loff_t pos, size_t count)
 {
@@ -162,7 +162,7 @@ static ssize_t smi_data_read(struct kobject *kobj,
        return ret;
 }
-static ssize_t smi_data_write(struct kobject *kobj,
+static ssize_t smi_data_write(struct file *filp, struct kobject *kobj,
                              struct bin_attribute *bin_attr,
                              char *buf, loff_t pos, size_t count)
 {
diff --git a/drivers/firmware/dell_rbu.c b/drivers/firmware/dell_rbu.c
index 3a4460265b10..2f452f1f7c8a 100644
--- a/drivers/firmware/dell_rbu.c
+++ b/drivers/firmware/dell_rbu.c
@@ -522,7 +522,7 @@ static ssize_t read_rbu_mono_data(char *buffer, loff_t pos, size_t count)
                        rbu_data.image_update_buffer, rbu_data.bios_image_size);
 }
-static ssize_t read_rbu_data(struct kobject *kobj,
+static ssize_t read_rbu_data(struct file *filp, struct kobject *kobj,
                             struct bin_attribute *bin_attr,
                             char *buffer, loff_t pos, size_t count)
 {
@@ -576,7 +576,7 @@ static void callbackfn_rbu(const struct firmware *fw, void *context)
        release_firmware(fw);
 }
-static ssize_t read_rbu_image_type(struct kobject *kobj,
+static ssize_t read_rbu_image_type(struct file *filp, struct kobject *kobj,
                                   struct bin_attribute *bin_attr,
                                   char *buffer, loff_t pos, size_t count)
 {
@@ -586,7 +586,7 @@ static ssize_t read_rbu_image_type(struct kobject *kobj,
        return size;
 }
-static ssize_t write_rbu_image_type(struct kobject *kobj,
+static ssize_t write_rbu_image_type(struct file *filp, struct kobject *kobj,
                                    struct bin_attribute *bin_attr,
                                    char *buffer, loff_t pos, size_t count)
 {
@@ -647,7 +647,7 @@ static ssize_t write_rbu_image_type(struct kobject *kobj,
        return rc;
 }
-static ssize_t read_rbu_packet_size(struct kobject *kobj,
+static ssize_t read_rbu_packet_size(struct file *filp, struct kobject *kobj,
                                    struct bin_attribute *bin_attr,
                                    char *buffer, loff_t pos, size_t count)
 {
@@ -660,7 +660,7 @@ static ssize_t read_rbu_packet_size(struct kobject *kobj,
        return size;
 }
-static ssize_t write_rbu_packet_size(struct kobject *kobj,
+static ssize_t write_rbu_packet_size(struct file *filp, struct kobject *kobj,
                                     struct bin_attribute *bin_attr,
                                     char *buffer, loff_t pos, size_t count)
 {
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efivars.c
index 81b70bd07586..2a62ec6390e0 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efivars.c
@@ -402,7 +402,7 @@ efivar_unregister(struct efivar_entry *var)
 }
-static ssize_t efivar_create(struct kobject *kobj,
+static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
                             struct bin_attribute *bin_attr,
                             char *buf, loff_t pos, size_t count)
 {
@@ -461,7 +461,7 @@ static ssize_t efivar_create(struct kobject *kobj,
        return count;
 }
-static ssize_t efivar_delete(struct kobject *kobj,
+static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
                             struct bin_attribute *bin_attr,
                             char *buf, loff_t pos, size_t count)
 {
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index eb0c3fe44b29..cae1b8c5b08c 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -399,7 +399,7 @@ static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
                        goto free_id;
                }
-                pdesc->value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
+                pdesc->value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value");
                if (!pdesc->value_sd) {
                        ret = -ENODEV;
                        goto free_id;
diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index 25bbd30ed7af..387166d5a109 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -193,8 +193,9 @@ static ssize_t enabled_show(struct device *device,
                        "disabled");
 }
-static ssize_t edid_show(struct kobject *kobj, struct bin_attribute *attr,
+static ssize_t edid_show(struct file *filp, struct kobject *kobj,
-                         char *buf, loff_t off, size_t count)
+                         struct bin_attribute *attr, char *buf, loff_t off,
+                         size_t count)
 {
        struct device *connector_dev = container_of(kobj, struct device, kobj);
        struct drm_connector *connector = to_drm_connector(connector_dev);
diff --git a/drivers/i2c/algos/i2c-algo-pca.c b/drivers/i2c/algos/i2c-algo-pca.c
index dcdaf8e675bf..2b9a8f54bb2c 100644
--- a/drivers/i2c/algos/i2c-algo-pca.c
+++ b/drivers/i2c/algos/i2c-algo-pca.c
@@ -109,13 +109,13 @@ static void pca_stop(struct i2c_algo_pca_data *adap)
 * returns after the address has been sent
 */
 static int pca_address(struct i2c_algo_pca_data *adap,
-                        struct i2c_msg *msg)
+                       struct i2c_msg *msg)
 {
        int sta = pca_get_con(adap);
        int addr;
-        addr = ( (0x7f & msg->addr) << 1 );
+        addr = ((0x7f & msg->addr) << 1);
-        if (msg->flags & I2C_M_RD )
+        if (msg->flags & I2C_M_RD)
                addr |= 1;
        DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n",
             msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr);
@@ -134,7 +134,7 @@ static int pca_address(struct i2c_algo_pca_data *adap,
 * Returns after the byte has been transmitted
 */
 static int pca_tx_byte(struct i2c_algo_pca_data *adap,
-                        __u8 b)
+                       __u8 b)
 {
        int sta = pca_get_con(adap);
        DEB2("=== WRITE %#04x\n", b);
@@ -164,13 +164,13 @@ static void pca_rx_byte(struct i2c_algo_pca_data *adap,
 * Returns after next byte has arrived.
 */
 static int pca_rx_ack(struct i2c_algo_pca_data *adap,
-                       int ack)
+                      int ack)
 {
        int sta = pca_get_con(adap);
        sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI|I2C_PCA_CON_AA);
-        if ( ack )
+        if (ack)
                sta |= I2C_PCA_CON_AA;
        pca_set_con(adap, sta);
@@ -178,12 +178,12 @@ static int pca_rx_ack(struct i2c_algo_pca_data *adap,
 }
 static int pca_xfer(struct i2c_adapter *i2c_adap,
-                    struct i2c_msg *msgs,
+                    struct i2c_msg *msgs,
-                    int num)
+                    int num)
 {
-        struct i2c_algo_pca_data *adap = i2c_adap->algo_data;
+        struct i2c_algo_pca_data *adap = i2c_adap->algo_data;
-        struct i2c_msg *msg = NULL;
+        struct i2c_msg *msg = NULL;
-        int curmsg;
+        int curmsg;
        int numbytes = 0;
        int state;
        int ret;
@@ -202,21 +202,21 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
        DEB1("{{{ XFER %d messages\n", num);
-        if (i2c_debug>=2) {
+        if (i2c_debug >= 2) {
                for (curmsg = 0; curmsg < num; curmsg++) {
                        int addr, i;
                        msg = &msgs[curmsg];
                        addr = (0x7f & msg->addr) ;
-                        if (msg->flags & I2C_M_RD )
+                        if (msg->flags & I2C_M_RD)
                                printk(KERN_INFO "    [%02d] RD %d bytes from %#02x [%#02x, ...]\n",
-                                       curmsg, msg->len, addr, (addr<<1) | 1);
+                                       curmsg, msg->len, addr, (addr << 1) | 1);
                        else {
                                printk(KERN_INFO "    [%02d] WR %d bytes to %#02x [%#02x%s",
-                                       curmsg, msg->len, addr, addr<<1,
+                                       curmsg, msg->len, addr, addr << 1,
                                       msg->len == 0 ? "" : ", ");
-                                for(i=0; i < msg->len; i++)
+                                for (i = 0; i < msg->len; i++)
                                        printk("%#04x%s", msg->buf[i], i == msg->len - 1 ? "" : ", ");
                                printk("]\n");
                        }
@@ -305,7 +305,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
                        goto out;
                case 0x58: /* Data byte has been received; NOT ACK has been returned */
-                        if ( numbytes == msg->len - 1 ) {
+                        if (numbytes == msg->len - 1) {
                                pca_rx_byte(adap, &msg->buf[numbytes], 0);
                                curmsg++; numbytes = 0;
                                if (curmsg == num)
@@ -352,7 +352,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
 static u32 pca_func(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 static const struct i2c_algorithm pca_algo = {
diff --git a/drivers/i2c/busses/i2c-ali1535.c b/drivers/i2c/busses/i2c-ali1535.c
index bd8f1e4d9e6c..906a3ca50db6 100644
--- a/drivers/i2c/busses/i2c-ali1535.c
+++ b/drivers/i2c/busses/i2c-ali1535.c
@@ -60,7 +60,7 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* ALI1535 SMBus address offsets */
diff --git a/drivers/i2c/busses/i2c-ali15x3.c b/drivers/i2c/busses/i2c-ali15x3.c
index 659f63f5e4af..b14f6d68221d 100644
--- a/drivers/i2c/busses/i2c-ali15x3.c
+++ b/drivers/i2c/busses/i2c-ali15x3.c
@@ -67,7 +67,7 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* ALI15X3 SMBus address offsets */
 #define SMBHSTSTS       (0 + ali15x3_smba)
diff --git a/drivers/i2c/busses/i2c-amd756.c b/drivers/i2c/busses/i2c-amd756.c
index c5a9fa488e7f..03bcd07c4697 100644
--- a/drivers/i2c/busses/i2c-amd756.c
+++ b/drivers/i2c/busses/i2c-amd756.c
@@ -43,7 +43,7 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* AMD756 SMBus address offsets */
 #define SMB_ADDR_OFFSET         0xE0
diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c
index 2fbef27b6cd6..af1e5e254b7b 100644
--- a/drivers/i2c/busses/i2c-amd8111.c
+++ b/drivers/i2c/busses/i2c-amd8111.c
@@ -18,7 +18,7 @@
 #include <linux/delay.h>
 #include <linux/acpi.h>
 #include <linux/slab.h>
-#include <asm/io.h>
+#include <linux/io.h>
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR ("Vojtech Pavlik <vojtech@suse.cz>");
diff --git a/drivers/i2c/busses/i2c-at91.c b/drivers/i2c/busses/i2c-at91.c
index 06e1ecb4919f..305c07504f7e 100644
--- a/drivers/i2c/busses/i2c-at91.c
+++ b/drivers/i2c/busses/i2c-at91.c
@@ -23,8 +23,7 @@
 #include <linux/init.h>
 #include <linux/clk.h>
 #include <linux/platform_device.h>
+#include <linux/io.h>
-#include <asm/io.h>
 #include <mach/at91_twi.h>
 #include <mach/board.h>
diff --git a/drivers/i2c/busses/i2c-elektor.c b/drivers/i2c/busses/i2c-elektor.c
index 612255614a66..e5b1a3bf5b80 100644
--- a/drivers/i2c/busses/i2c-elektor.c
+++ b/drivers/i2c/busses/i2c-elektor.c
@@ -37,8 +37,8 @@
 #include <linux/isa.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-pcf.h>
+#include <linux/io.h>
-#include <asm/io.h>
 #include <asm/irq.h>
 #include "../algos/i2c-algo-pcf.h"
diff --git a/drivers/i2c/busses/i2c-gpio.c b/drivers/i2c/busses/i2c-gpio.c
index c21077d248af..d9aa9a649e35 100644
--- a/drivers/i2c/busses/i2c-gpio.c
+++ b/drivers/i2c/busses/i2c-gpio.c
@@ -211,7 +211,7 @@ static int __init i2c_gpio_init(void)
        return ret;
 }
-module_init(i2c_gpio_init);
+subsys_initcall(i2c_gpio_init);
 static void __exit i2c_gpio_exit(void)
 {
diff --git a/drivers/i2c/busses/i2c-hydra.c b/drivers/i2c/busses/i2c-hydra.c
index c767295ad1fb..9ff1695d8458 100644
--- a/drivers/i2c/busses/i2c-hydra.c
+++ b/drivers/i2c/busses/i2c-hydra.c
@@ -28,7 +28,7 @@
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
 #include <linux/init.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/hydra.h>
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index 299b918455a3..f4b21f2bb8ed 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -138,6 +138,17 @@ static struct pci_dev *I801_dev;
 #define FEATURE_I2C_BLOCK_READ  (1 << 3)
 static unsigned int i801_features;
+static const char *i801_feature_names[] = {
+        "SMBus PEC",
+        "Block buffer",
+        "Block process call",
+        "I2C block read",
+};
+static unsigned int disable_features;
+module_param(disable_features, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(disable_features, "Disable selected driver features");
 /* Make sure the SMBus host is ready to start transmitting.
   Return 0 if it is, -EBUSY if it is not. */
 static int i801_check_pre(void)
@@ -341,9 +352,8 @@ static int i801_block_transaction_byte_by_byte(union i2c_smbus_data *data,
                do {
                        msleep(1);
                        status = inb_p(SMBHSTSTS);
-                }
+                } while ((!(status & SMBHSTSTS_BYTE_DONE))
-                while ((!(status & SMBHSTSTS_BYTE_DONE))
+                         && (timeout++ < MAX_TIMEOUT));
-                       && (timeout++ < MAX_TIMEOUT));
                result = i801_check_post(status, timeout > MAX_TIMEOUT);
                if (result < 0)
@@ -440,9 +450,9 @@ static int i801_block_transaction(union i2c_smbus_data *data, char read_write,
 }
 /* Return negative errno on error. */
-static s32 i801_access(struct i2c_adapter * adap, u16 addr,
+static s32 i801_access(struct i2c_adapter *adap, u16 addr,
                       unsigned short flags, char read_write, u8 command,
-                       int size, union i2c_smbus_data * data)
+                       int size, union i2c_smbus_data *data)
 {
        int hwpec;
        int block = 0;
@@ -511,7 +521,7 @@ static s32 i801_access(struct i2c_adapter * adap, u16 addr,
        else
                outb_p(inb_p(SMBAUXCTL) & (~SMBAUXCTL_CRC), SMBAUXCTL);
-        if(block)
+        if (block)
                ret = i801_block_transaction(data, read_write, size, hwpec);
        else
                ret = i801_transaction(xact | ENABLE_INT9);
@@ -523,9 +533,9 @@ static s32 i801_access(struct i2c_adapter * adap, u16 addr,
                outb_p(inb_p(SMBAUXCTL) & ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B),
                       SMBAUXCTL);
-        if(block)
+        if (block)
                return ret;
-        if(ret)
+        if (ret)
                return ret;
        if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
                return 0;
@@ -585,7 +595,7 @@ static const struct pci_device_id i801_ids[] = {
        { 0, }
 };
-MODULE_DEVICE_TABLE (pci, i801_ids);
+MODULE_DEVICE_TABLE(pci, i801_ids);
 #if defined CONFIG_INPUT_APANEL || defined CONFIG_INPUT_APANEL_MODULE
 static unsigned char apanel_addr;
@@ -689,10 +699,11 @@ static void __devinit dmi_check_onboard_devices(const struct dmi_header *dm,
 }
 #endif
-static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
+static int __devinit i801_probe(struct pci_dev *dev,
+                                const struct pci_device_id *id)
 {
        unsigned char temp;
-        int err;
+        int err, i;
 #if defined CONFIG_SENSORS_FSCHMD || defined CONFIG_SENSORS_FSCHMD_MODULE
        const char *vendor;
 #endif
@@ -700,26 +711,28 @@ static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id
        I801_dev = dev;
        i801_features = 0;
        switch (dev->device) {
-        case PCI_DEVICE_ID_INTEL_82801EB_3:
+        default:
-        case PCI_DEVICE_ID_INTEL_ESB_4:
-        case PCI_DEVICE_ID_INTEL_ICH6_16:
-        case PCI_DEVICE_ID_INTEL_ICH7_17:
-        case PCI_DEVICE_ID_INTEL_ESB2_17:
-        case PCI_DEVICE_ID_INTEL_ICH8_5:
-        case PCI_DEVICE_ID_INTEL_ICH9_6:
-        case PCI_DEVICE_ID_INTEL_TOLAPAI_1:
-        case PCI_DEVICE_ID_INTEL_ICH10_4:
-        case PCI_DEVICE_ID_INTEL_ICH10_5:
-        case PCI_DEVICE_ID_INTEL_PCH_SMBUS:
-        case PCI_DEVICE_ID_INTEL_CPT_SMBUS:
                i801_features |= FEATURE_I2C_BLOCK_READ;
                /* fall through */
        case PCI_DEVICE_ID_INTEL_82801DB_3:
                i801_features |= FEATURE_SMBUS_PEC;
                i801_features |= FEATURE_BLOCK_BUFFER;
+                /* fall through */
+        case PCI_DEVICE_ID_INTEL_82801CA_3:
+        case PCI_DEVICE_ID_INTEL_82801BA_2:
+        case PCI_DEVICE_ID_INTEL_82801AB_3:
+        case PCI_DEVICE_ID_INTEL_82801AA_3:
                break;
        }
+        /* Disable features on user request */
+        for (i = 0; i < ARRAY_SIZE(i801_feature_names); i++) {
+                if (i801_features & disable_features & (1 << i))
+                        dev_notice(&dev->dev, "%s disabled by user\n",
+                                   i801_feature_names[i]);
+        }
+        i801_features &= ~disable_features;
        err = pci_enable_device(dev);
        if (err) {
                dev_err(&dev->dev, "Failed to enable SMBus PCI device (%d)\n",
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 2bef534cbff1..f8ccc0fe95a8 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -39,7 +39,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <asm/irq.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/i2c.h>
 #include <linux/i2c-id.h>
 #include <linux/of_platform.h>
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index 5901707fc66a..112c61f7b8cd 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -38,8 +38,7 @@
 #include <linux/errno.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
+#include <linux/io.h>
-#include <asm/io.h>
 #include "i2c-iop3xx.h"
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index 3623a4499084..16242063144f 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -17,8 +17,7 @@
 #include <linux/interrupt.h>
 #include <linux/mv643xx_i2c.h>
 #include <linux/platform_device.h>
+#include <linux/io.h>
-#include <asm/io.h>
 /* Register defines */
 #define MV64XXX_I2C_REG_SLAVE_ADDR                      0x00
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index 4a48dd4ef787..a605a5029cfe 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -57,7 +57,7 @@
 #include <linux/dmi.h>
 #include <linux/acpi.h>
 #include <linux/slab.h>
-#include <asm/io.h>
+#include <linux/io.h>
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR ("Hans-Frieder Vogt <hfvogt@gmx.net>");
@@ -404,10 +404,9 @@ static int __devinit nforce2_probe(struct pci_dev *dev, const struct pci_device_
        /* SMBus adapter 1 */
        res1 = nforce2_probe_smb(dev, 4, NFORCE_PCI_SMB1, &smbuses[0], "SMB1");
-        if (res1 < 0) {
+        if (res1 < 0)
-                dev_err(&dev->dev, "Error probing SMB1.\n");
                smbuses[0].base = 0;    /* to have a check value */
-        }
        /* SMBus adapter 2 */
        if (dmi_check_system(nforce2_dmi_blacklist2)) {
                dev_err(&dev->dev, "Disabling SMB2 for safety reasons.\n");
@@ -416,11 +415,10 @@ static int __devinit nforce2_probe(struct pci_dev *dev, const struct pci_device_
        } else {
                res2 = nforce2_probe_smb(dev, 5, NFORCE_PCI_SMB2, &smbuses[1],
                                         "SMB2");
-                if (res2 < 0) {
+                if (res2 < 0)
-                        dev_err(&dev->dev, "Error probing SMB2.\n");
                        smbuses[1].base = 0;    /* to have a check value */
-                }
        }
        if ((res1 < 0) && (res2 < 0)) {
                /* we did not find even one of the SMBuses, so we give up */
                kfree(smbuses);
diff --git a/drivers/i2c/busses/i2c-ocores.c b/drivers/i2c/busses/i2c-ocores.c
index b4ed4ca802ed..0070371b29f3 100644
--- a/drivers/i2c/busses/i2c-ocores.c
+++ b/drivers/i2c/busses/i2c-ocores.c
@@ -19,7 +19,7 @@
 #include <linux/wait.h>
 #include <linux/i2c-ocores.h>
 #include <linux/slab.h>
-#include <asm/io.h>
+#include <linux/io.h>
 struct ocores_i2c {
        void __iomem *base;
diff --git a/drivers/i2c/busses/i2c-parport-light.c b/drivers/i2c/busses/i2c-parport-light.c
index 5f41ec0f72d2..fc5fbd1012c9 100644
--- a/drivers/i2c/busses/i2c-parport-light.c
+++ b/drivers/i2c/busses/i2c-parport-light.c
@@ -33,7 +33,7 @@
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
 #include <linux/i2c-smbus.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include "i2c-parport.h"
 #define DEFAULT_BASE 0x378
diff --git a/drivers/i2c/busses/i2c-parport.c b/drivers/i2c/busses/i2c-parport.c
index 846583ed4763..0eb1515541e7 100644
--- a/drivers/i2c/busses/i2c-parport.c
+++ b/drivers/i2c/busses/i2c-parport.c
@@ -137,7 +137,7 @@ static int parport_getsda(void *data)
   copied. The attaching code will set getscl to NULL for adapters that
   cannot read SCL back, and will also make the data field point to
   the parallel port structure. */
-static struct i2c_algo_bit_data parport_algo_data = {
+static const struct i2c_algo_bit_data parport_algo_data = {
        .setsda         = parport_setsda,
        .setscl         = parport_setscl,
        .getsda         = parport_getsda,
diff --git a/drivers/i2c/busses/i2c-pasemi.c b/drivers/i2c/busses/i2c-pasemi.c
index d3d4a4b43a1d..4174101660c9 100644
--- a/drivers/i2c/busses/i2c-pasemi.c
+++ b/drivers/i2c/busses/i2c-pasemi.c
@@ -25,7 +25,7 @@
 #include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
-#include <asm/io.h>
+#include <linux/io.h>
 static struct pci_driver pasemi_smb_driver;
diff --git a/drivers/i2c/busses/i2c-pca-isa.c b/drivers/i2c/busses/i2c-pca-isa.c
index f7346a9bd95f..bbd77603a417 100644
--- a/drivers/i2c/busses/i2c-pca-isa.c
+++ b/drivers/i2c/busses/i2c-pca-isa.c
@@ -30,8 +30,8 @@
 #include <linux/isa.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-pca.h>
+#include <linux/io.h>
-#include <asm/io.h>
 #include <asm/irq.h>
 #define DRIVER "i2c-pca-isa"
diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c
index 5b2213df5ed0..ef5c78487eb7 100644
--- a/drivers/i2c/busses/i2c-pca-platform.c
+++ b/drivers/i2c/busses/i2c-pca-platform.c
@@ -23,9 +23,9 @@
 #include <linux/i2c-algo-pca.h>
 #include <linux/i2c-pca-platform.h>
 #include <linux/gpio.h>
+#include <linux/io.h>
 #include <asm/irq.h>
-#include <asm/io.h>
 struct i2c_pca_pf_data {
        void __iomem                    *reg_base;
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index ee9da6fcf69a..6d14ac2e3c41 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -39,7 +39,7 @@
 #include <linux/init.h>
 #include <linux/dmi.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* PIIX4 SMBus address offsets */
diff --git a/drivers/i2c/busses/i2c-pmcmsp.c b/drivers/i2c/busses/i2c-pmcmsp.c
index 7b57d5f267e1..dfa7ae9c1b8e 100644
--- a/drivers/i2c/busses/i2c-pmcmsp.c
+++ b/drivers/i2c/busses/i2c-pmcmsp.c
@@ -33,7 +33,7 @@
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <linux/delay.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #define DRV_NAME        "pmcmsptwi"
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index fbde6f614059..020ff23d762f 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -34,9 +34,9 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <asm/irq.h>
-#include <asm/io.h>
 #include <plat/i2c.h>
 /*
diff --git a/drivers/i2c/busses/i2c-s3c2410.c b/drivers/i2c/busses/i2c-s3c2410.c
index ec3256cce91e..72902e0bbfa7 100644
--- a/drivers/i2c/busses/i2c-s3c2410.c
+++ b/drivers/i2c/busses/i2c-s3c2410.c
@@ -35,9 +35,9 @@
 #include <linux/clk.h>
 #include <linux/cpufreq.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <asm/irq.h>
-#include <asm/io.h>
 #include <plat/regs-iic.h>
 #include <plat/iic.h>
diff --git a/drivers/i2c/busses/i2c-s6000.c b/drivers/i2c/busses/i2c-s6000.c
index c91359f4965c..cadc0216e02f 100644
--- a/drivers/i2c/busses/i2c-s6000.c
+++ b/drivers/i2c/busses/i2c-s6000.c
@@ -36,8 +36,8 @@
 #include <linux/completion.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
+#include <linux/io.h>
-#include <asm/io.h>
 #include "i2c-s6000.h"
 #define DRV_NAME "i2c-s6000"
diff --git a/drivers/i2c/busses/i2c-sh7760.c b/drivers/i2c/busses/i2c-sh7760.c
index b9680f50f541..4f93da31d3ad 100644
--- a/drivers/i2c/busses/i2c-sh7760.c
+++ b/drivers/i2c/busses/i2c-sh7760.c
@@ -16,10 +16,10 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <asm/clock.h>
 #include <asm/i2c-sh7760.h>
-#include <asm/io.h>
 /* register offsets */
 #define I2CSCR          0x0             /* slave ctrl           */
diff --git a/drivers/i2c/busses/i2c-sibyte.c b/drivers/i2c/busses/i2c-sibyte.c
index 98b1ec489159..3d76a188e42f 100644
--- a/drivers/i2c/busses/i2c-sibyte.c
+++ b/drivers/i2c/busses/i2c-sibyte.c
@@ -22,7 +22,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/i2c.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/sibyte/sb1250_regs.h>
 #include <asm/sibyte/sb1250_smbus.h>
diff --git a/drivers/i2c/busses/i2c-simtec.c b/drivers/i2c/busses/i2c-simtec.c
index 78b06107342c..2fc08fbf67a2 100644
--- a/drivers/i2c/busses/i2c-simtec.c
+++ b/drivers/i2c/busses/i2c-simtec.c
@@ -24,12 +24,11 @@
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
-#include <asm/io.h>
 struct simtec_i2c_data {
        struct resource         *ioarea;
        void __iomem            *reg;
diff --git a/drivers/i2c/busses/i2c-sis5595.c b/drivers/i2c/busses/i2c-sis5595.c
index 55a71370c79b..437586611d4a 100644
--- a/drivers/i2c/busses/i2c-sis5595.c
+++ b/drivers/i2c/busses/i2c-sis5595.c
@@ -61,7 +61,7 @@
 #include <linux/init.h>
 #include <linux/i2c.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 static int blacklist[] = {
        PCI_DEVICE_ID_SI_540,
diff --git a/drivers/i2c/busses/i2c-sis630.c b/drivers/i2c/busses/i2c-sis630.c
index 2309c7f1bde2..e6f539e26f65 100644
--- a/drivers/i2c/busses/i2c-sis630.c
+++ b/drivers/i2c/busses/i2c-sis630.c
@@ -53,7 +53,7 @@
 #include <linux/init.h>
 #include <linux/i2c.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* SIS630 SMBus registers */
 #define SMB_STS                 0x80    /* status */
diff --git a/drivers/i2c/busses/i2c-sis96x.c b/drivers/i2c/busses/i2c-sis96x.c
index d43d8f8943dd..86837f0c4cb9 100644
--- a/drivers/i2c/busses/i2c-sis96x.c
+++ b/drivers/i2c/busses/i2c-sis96x.c
@@ -38,7 +38,7 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* base address register in PCI config space */
 #define SIS96x_BAR 0x04
diff --git a/drivers/i2c/busses/i2c-stub.c b/drivers/i2c/busses/i2c-stub.c
index 0c770eabe85e..b1b3447942c9 100644
--- a/drivers/i2c/busses/i2c-stub.c
+++ b/drivers/i2c/busses/i2c-stub.c
@@ -29,13 +29,16 @@
 #include <linux/i2c.h>
 #define MAX_CHIPS 10
+#define STUB_FUNC (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | \
+                   I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | \
+                   I2C_FUNC_SMBUS_I2C_BLOCK)
 static unsigned short chip_addr[MAX_CHIPS];
 module_param_array(chip_addr, ushort, NULL, S_IRUGO);
 MODULE_PARM_DESC(chip_addr,
                 "Chip addresses (up to 10, between 0x03 and 0x77)");
-static unsigned long functionality = ~0UL;
+static unsigned long functionality = STUB_FUNC;
 module_param(functionality, ulong, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(functionality, "Override functionality bitfield");
@@ -156,9 +159,7 @@ static s32 stub_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
 static u32 stub_func(struct i2c_adapter *adapter)
 {
-        return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+        return STUB_FUNC & functionality;
-                I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
-                I2C_FUNC_SMBUS_I2C_BLOCK) & functionality;
 }
 static const struct i2c_algorithm smbus_algorithm = {
diff --git a/drivers/i2c/busses/i2c-versatile.c b/drivers/i2c/busses/i2c-versatile.c
index 5c473833d948..60556012312f 100644
--- a/drivers/i2c/busses/i2c-versatile.c
+++ b/drivers/i2c/busses/i2c-versatile.c
@@ -15,8 +15,7 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/io.h>
-#include <asm/io.h>
 #define I2C_CONTROL     0x00
 #define I2C_CONTROLS    0x00
diff --git a/drivers/i2c/busses/i2c-via.c b/drivers/i2c/busses/i2c-via.c
index de78283bddbe..7799fe5bda88 100644
--- a/drivers/i2c/busses/i2c-via.c
+++ b/drivers/i2c/busses/i2c-via.c
@@ -25,7 +25,7 @@
 #include <linux/init.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
-#include <asm/io.h>
+#include <linux/io.h>
 /* Power management registers */
 #define PM_CFG_REVID    0x08    /* silicon revision code */
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c
index d57292e5dae0..4c6fff5f330d 100644
--- a/drivers/i2c/busses/i2c-viapro.c
+++ b/drivers/i2c/busses/i2c-viapro.c
@@ -51,7 +51,7 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
-#include <asm/io.h>
+#include <linux/io.h>
 static struct pci_dev *vt596_pdev;
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index 684395b6f3e2..4cb4bb009950 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -32,7 +32,7 @@
 #include <linux/delay.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/scx200.h>
@@ -552,7 +552,7 @@ static int __init scx200_create_isa(const char *text, unsigned long base,
 * the name and the BAR where the I/O address resource is located.  ISA
 * devices are flagged with a bar value of -1 */
-static struct pci_device_id scx200_pci[] = {
+static const struct pci_device_id scx200_pci[] __initconst = {
        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE),
          .driver_data = 0 },
        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE),
diff --git a/drivers/i2c/busses/scx200_i2c.c b/drivers/i2c/busses/scx200_i2c.c
index 42df0eca43d5..7ee0d502ceab 100644
--- a/drivers/i2c/busses/scx200_i2c.c
+++ b/drivers/i2c/busses/scx200_i2c.c
@@ -27,7 +27,7 @@
 #include <linux/init.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/scx200_gpio.h>
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 7c469a62c3c1..db3c9f3a7647 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -1221,10 +1221,10 @@ EXPORT_SYMBOL(i2c_transfer);
 *
 * Returns negative errno, or else the number of bytes written.
 */
-int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
+int i2c_master_send(struct i2c_client *client, const char *buf, int count)
 {
        int ret;
-        struct i2c_adapter *adap=client->adapter;
+        struct i2c_adapter *adap = client->adapter;
        struct i2c_msg msg;
        msg.addr = client->addr;
@@ -1248,9 +1248,9 @@ EXPORT_SYMBOL(i2c_master_send);
 *
 * Returns negative errno, or else the number of bytes read.
 */
-int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
+int i2c_master_recv(struct i2c_client *client, char *buf, int count)
 {
-        struct i2c_adapter *adap=client->adapter;
+        struct i2c_adapter *adap = client->adapter;
        struct i2c_msg msg;
        int ret;
@@ -1452,7 +1452,7 @@ i2c_new_probed_device(struct i2c_adapter *adap,
 }
 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
-struct i2c_adapter* i2c_get_adapter(int id)
+struct i2c_adapter *i2c_get_adapter(int id)
 {
        struct i2c_adapter *adapter;
@@ -1479,7 +1479,7 @@ static u8 crc8(u16 data)
 {
        int i;
-        for(i = 0; i < 8; i++) {
+        for (i = 0; i < 8; i++) {
                if (data & 0x8000)
                        data = data ^ POLY;
                data = data << 1;
@@ -1492,7 +1492,7 @@ static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
 {
        int i;
-        for(i = 0; i < count; i++)
+        for (i = 0; i < count; i++)
                crc = crc8((crc ^ p[i]) << 8);
        return crc;
 }
@@ -1562,7 +1562,7 @@ EXPORT_SYMBOL(i2c_smbus_read_byte);
 */
 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
 {
-        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
+        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
                              I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 }
 EXPORT_SYMBOL(i2c_smbus_write_byte);
@@ -1600,9 +1600,9 @@ s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
 {
        union i2c_smbus_data data;
        data.byte = value;
-        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
+        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
-                              I2C_SMBUS_WRITE,command,
+                              I2C_SMBUS_WRITE, command,
-                              I2C_SMBUS_BYTE_DATA,&data);
+                              I2C_SMBUS_BYTE_DATA, &data);
 }
 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
@@ -1639,9 +1639,9 @@ s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
 {
        union i2c_smbus_data data;
        data.word = value;
-        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
+        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
-                              I2C_SMBUS_WRITE,command,
+                              I2C_SMBUS_WRITE, command,
-                              I2C_SMBUS_WORD_DATA,&data);
+                              I2C_SMBUS_WORD_DATA, &data);
 }
 EXPORT_SYMBOL(i2c_smbus_write_word_data);
@@ -1718,9 +1718,9 @@ s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
                length = I2C_SMBUS_BLOCK_MAX;
        data.block[0] = length;
        memcpy(&data.block[1], values, length);
-        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
+        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
-                              I2C_SMBUS_WRITE,command,
+                              I2C_SMBUS_WRITE, command,
-                              I2C_SMBUS_BLOCK_DATA,&data);
+                              I2C_SMBUS_BLOCK_DATA, &data);
 }
 EXPORT_SYMBOL(i2c_smbus_write_block_data);
@@ -1762,10 +1762,10 @@ EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
 /* Simulate a SMBus command using the i2c protocol
   No checking of parameters is done!  */
-static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
+static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
-                                   unsigned short flags,
+                                   unsigned short flags,
-                                   char read_write, u8 command, int size,
+                                   char read_write, u8 command, int size,
-                                   union i2c_smbus_data * data)
+                                   union i2c_smbus_data *data)
 {
        /* So we need to generate a series of msgs. In the case of writing, we
          need to use only one message; when reading, we need two. We initialize
@@ -1773,7 +1773,7 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
          simpler. */
        unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
        unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
-        int num = read_write == I2C_SMBUS_READ?2:1;
+        int num = read_write == I2C_SMBUS_READ ? 2 : 1;
        struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
                                  { addr, flags | I2C_M_RD, 0, msgbuf1 }
                                };
@@ -1782,7 +1782,7 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
        int status;
        msgbuf0[0] = command;
-        switch(size) {
+        switch (size) {
        case I2C_SMBUS_QUICK:
                msg[0].len = 0;
                /* Special case: The read/write field is used as data */
@@ -1809,7 +1809,7 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
                if (read_write == I2C_SMBUS_READ)
                        msg[1].len = 2;
                else {
-                        msg[0].len=3;
+                        msg[0].len = 3;
                        msgbuf0[1] = data->word & 0xff;
                        msgbuf0[2] = data->word >> 8;
                }
@@ -1902,26 +1902,26 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
        }
        if (read_write == I2C_SMBUS_READ)
-                switch(size) {
+                switch (size) {
-                        case I2C_SMBUS_BYTE:
+                case I2C_SMBUS_BYTE:
-                                data->byte = msgbuf0[0];
+                        data->byte = msgbuf0[0];
-                                break;
+                        break;
-                        case I2C_SMBUS_BYTE_DATA:
+                case I2C_SMBUS_BYTE_DATA:
-                                data->byte = msgbuf1[0];
+                        data->byte = msgbuf1[0];
-                                break;
+                        break;
-                        case I2C_SMBUS_WORD_DATA:
+                case I2C_SMBUS_WORD_DATA:
-                        case I2C_SMBUS_PROC_CALL:
+                case I2C_SMBUS_PROC_CALL:
-                                data->word = msgbuf1[0] | (msgbuf1[1] << 8);
+                        data->word = msgbuf1[0] | (msgbuf1[1] << 8);
-                                break;
+                        break;
-                        case I2C_SMBUS_I2C_BLOCK_DATA:
+                case I2C_SMBUS_I2C_BLOCK_DATA:
-                                for (i = 0; i < data->block[0]; i++)
+                        for (i = 0; i < data->block[0]; i++)
-                                        data->block[i+1] = msgbuf1[i];
+                                data->block[i+1] = msgbuf1[i];
-                                break;
+                        break;
-                        case I2C_SMBUS_BLOCK_DATA:
+                case I2C_SMBUS_BLOCK_DATA:
-                        case I2C_SMBUS_BLOCK_PROC_CALL:
+                case I2C_SMBUS_BLOCK_PROC_CALL:
-                                for (i = 0; i < msgbuf1[0] + 1; i++)
+                        for (i = 0; i < msgbuf1[0] + 1; i++)
-                                        data->block[i] = msgbuf1[i];
+                                data->block[i] = msgbuf1[i];
-                                break;
+                        break;
                }
        return 0;
 }
@@ -1966,7 +1966,7 @@ s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
                }
                rt_mutex_unlock(&adapter->bus_lock);
        } else
-                res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
+                res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
                                              command, protocol, data);
        return res;
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index f4110aa49600..e0694e4d86c7 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -35,7 +35,7 @@
 #include <linux/i2c.h>
 #include <linux/i2c-dev.h>
 #include <linux/jiffies.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 static struct i2c_driver i2cdev_driver;
@@ -132,45 +132,45 @@ static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
 * needed by those system calls and by this SMBus interface.
 */
-static ssize_t i2cdev_read (struct file *file, char __user *buf, size_t count,
+static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,
-                            loff_t *offset)
+                loff_t *offset)
 {
        char *tmp;
        int ret;
-        struct i2c_client *client = (struct i2c_client *)file->private_data;
+        struct i2c_client *client = file->private_data;
        if (count > 8192)
                count = 8192;
-        tmp = kmalloc(count,GFP_KERNEL);
+        tmp = kmalloc(count, GFP_KERNEL);
-        if (tmp==NULL)
+        if (tmp == NULL)
                return -ENOMEM;
        pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
                iminor(file->f_path.dentry->d_inode), count);
-        ret = i2c_master_recv(client,tmp,count);
+        ret = i2c_master_recv(client, tmp, count);
        if (ret >= 0)
-                ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
+                ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
        kfree(tmp);
        return ret;
 }
-static ssize_t i2cdev_write (struct file *file, const char __user *buf, size_t count,
+static ssize_t i2cdev_write(struct file *file, const char __user *buf,
-                             loff_t *offset)
+                size_t count, loff_t *offset)
 {
        int ret;
        char *tmp;
-        struct i2c_client *client = (struct i2c_client *)file->private_data;
+        struct i2c_client *client = file->private_data;
        if (count > 8192)
                count = 8192;
-        tmp = kmalloc(count,GFP_KERNEL);
+        tmp = kmalloc(count, GFP_KERNEL);
-        if (tmp==NULL)
+        if (tmp == NULL)
                return -ENOMEM;
-        if (copy_from_user(tmp,buf,count)) {
+        if (copy_from_user(tmp, buf, count)) {
                kfree(tmp);
                return -EFAULT;
        }
@@ -178,7 +178,7 @@ static ssize_t i2cdev_write (struct file *file, const char __user *buf, size_t c
        pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
                iminor(file->f_path.dentry->d_inode), count);
-        ret = i2c_master_send(client,tmp,count);
+        ret = i2c_master_send(client, tmp, count);
        kfree(tmp);
        return ret;
 }
@@ -369,13 +369,13 @@ static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
 static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct i2c_client *client = (struct i2c_client *)file->private_data;
+        struct i2c_client *client = file->private_data;
        unsigned long funcs;
        dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
                cmd, arg);
-        switch ( cmd ) {
+        switch (cmd) {
        case I2C_SLAVE:
        case I2C_SLAVE_FORCE:
                /* NOTE:  devices set up to work with "new style" drivers
@@ -601,7 +601,7 @@ static void __exit i2c_dev_exit(void)
 {
        i2c_del_driver(&i2cdev_driver);
        class_destroy(i2c_dev_class);
-        unregister_chrdev(I2C_MAJOR,"i2c");
+        unregister_chrdev(I2C_MAJOR, "i2c");
 }
 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index 7e319d65ec57..f34f1dbeb577 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -209,4 +209,20 @@ config SERIO_ALTERA_PS2
          To compile this driver as a module, choose M here: the
          module will be called altera_ps2.
+config SERIO_AMS_DELTA
+        tristate "Amstrad Delta (E3) mailboard support"
+        depends on MACH_AMS_DELTA
+        default y
+        select AMS_DELTA_FIQ
+        ---help---
+          Say Y here if you have an E3 and want to use its mailboard,
+          or any standard AT keyboard connected to the mailboard port.
+          When used for the E3 mailboard, a non-standard key table
+          must be loaded from userspace, possibly using udev extras
+          provided keymap helper utility.
+          To compile this driver as a module, choose M here;
+          the module will be called ams_delta_serio.
 endif
diff --git a/drivers/input/serio/Makefile b/drivers/input/serio/Makefile
index bf945f789d05..84c80bf7185e 100644
--- a/drivers/input/serio/Makefile
+++ b/drivers/input/serio/Makefile
@@ -21,5 +21,6 @@ obj-$(CONFIG_SERIO_PCIPS2)	+= pcips2.o
 obj-$(CONFIG_SERIO_MACEPS2)     += maceps2.o
 obj-$(CONFIG_SERIO_LIBPS2)      += libps2.o
 obj-$(CONFIG_SERIO_RAW)         += serio_raw.o
+obj-$(CONFIG_SERIO_AMS_DELTA)   += ams_delta_serio.o
 obj-$(CONFIG_SERIO_XILINX_XPS_PS2)      += xilinx_ps2.o
 obj-$(CONFIG_SERIO_ALTERA_PS2)  += altera_ps2.o
diff --git a/drivers/input/serio/ams_delta_serio.c b/drivers/input/serio/ams_delta_serio.c
new file mode 100644
index 000000000000..8f1770e1e08b
--- /dev/null
+++ b/drivers/input/serio/ams_delta_serio.c
@@ -0,0 +1,177 @@
+/*
+ *  Amstrad E3 (Delta) keyboard port driver
+ *
+ *  Copyright (c) 2006 Matt Callow
+ *  Copyright (c) 2010 Janusz Krzysztofik
+ *
+ * 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.
+ *
+ * Thanks to Cliff Lawson for his help
+ *
+ * The Amstrad Delta keyboard (aka mailboard) uses normal PC-AT style serial
+ * transmission.  The keyboard port is formed of two GPIO lines, for clock
+ * and data.  Due to strict timing requirements of the interface,
+ * the serial data stream is read and processed by a FIQ handler.
+ * The resulting words are fetched by this driver from a circular buffer.
+ *
+ * Standard AT keyboard driver (atkbd) is used for handling the keyboard data.
+ * However, when used with the E3 mailboard that producecs non-standard
+ * scancodes, a custom key table must be prepared and loaded from userspace.
+ */
+#include <linux/gpio.h>
+#include <linux/irq.h>
+#include <linux/serio.h>
+#include <linux/slab.h>
+#include <asm/mach-types.h>
+#include <plat/board-ams-delta.h>
+#include <mach/ams-delta-fiq.h>
+MODULE_AUTHOR("Matt Callow");
+MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver");
+MODULE_LICENSE("GPL");
+static struct serio *ams_delta_serio;
+static int check_data(int data)
+{
+        int i, parity = 0;
+        /* check valid stop bit */
+        if (!(data & 0x400)) {
+                dev_warn(&ams_delta_serio->dev,
+                                "invalid stop bit, data=0x%X\n",
+                                data);
+                return SERIO_FRAME;
+        }
+        /* calculate the parity */
+        for (i = 1; i < 10; i++) {
+                if (data & (1 << i))
+                        parity++;
+        }
+        /* it should be odd */
+        if (!(parity & 0x01)) {
+                dev_warn(&ams_delta_serio->dev,
+                                "paritiy check failed, data=0x%X parity=0x%X\n",
+                                data, parity);
+                return SERIO_PARITY;
+        }
+        return 0;
+}
+static irqreturn_t ams_delta_serio_interrupt(int irq, void *dev_id)
+{
+        int *circ_buff = &fiq_buffer[FIQ_CIRC_BUFF];
+        int data, dfl;
+        u8 scancode;
+        fiq_buffer[FIQ_IRQ_PEND] = 0;
+        /*
+         * Read data from the circular buffer, check it
+         * and then pass it on the serio
+         */
+        while (fiq_buffer[FIQ_KEYS_CNT] > 0) {
+                data = circ_buff[fiq_buffer[FIQ_HEAD_OFFSET]++];
+                fiq_buffer[FIQ_KEYS_CNT]--;
+                if (fiq_buffer[FIQ_HEAD_OFFSET] == fiq_buffer[FIQ_BUF_LEN])
+                        fiq_buffer[FIQ_HEAD_OFFSET] = 0;
+                dfl = check_data(data);
+                scancode = (u8) (data >> 1) & 0xFF;
+                serio_interrupt(ams_delta_serio, scancode, dfl);
+        }
+        return IRQ_HANDLED;
+}
+static int ams_delta_serio_open(struct serio *serio)
+{
+        /* enable keyboard */
+        ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR,
+                        AMD_DELTA_LATCH2_KEYBRD_PWR);
+        return 0;
+}
+static void ams_delta_serio_close(struct serio *serio)
+{
+        /* disable keyboard */
+        ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR, 0);
+}
+static int __init ams_delta_serio_init(void)
+{
+        int err;
+        if (!machine_is_ams_delta())
+                return -ENODEV;
+        ams_delta_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
+        if (!ams_delta_serio)
+                return -ENOMEM;
+        ams_delta_serio->id.type = SERIO_8042;
+        ams_delta_serio->open = ams_delta_serio_open;
+        ams_delta_serio->close = ams_delta_serio_close;
+        strlcpy(ams_delta_serio->name, "AMS DELTA keyboard adapter",
+                        sizeof(ams_delta_serio->name));
+        strlcpy(ams_delta_serio->phys, "GPIO/serio0",
+                        sizeof(ams_delta_serio->phys));
+        err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_DATA, "serio-data");
+        if (err) {
+                pr_err("ams_delta_serio: Couldn't request gpio pin for data\n");
+                goto serio;
+        }
+        gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
+        err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_CLK, "serio-clock");
+        if (err) {
+                pr_err("ams_delta_serio: couldn't request gpio pin for clock\n");
+                goto gpio_data;
+        }
+        gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
+        err = request_irq(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
+                        ams_delta_serio_interrupt, IRQ_TYPE_EDGE_RISING,
+                        "ams-delta-serio", 0);
+        if (err < 0) {
+                pr_err("ams_delta_serio: couldn't request gpio interrupt %d\n",
+                                gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK));
+                goto gpio_clk;
+        }
+        /*
+         * Since GPIO register handling for keyboard clock pin is performed
+         * at FIQ level, switch back from edge to simple interrupt handler
+         * to avoid bad interaction.
+         */
+        set_irq_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
+                        handle_simple_irq);
+        serio_register_port(ams_delta_serio);
+        dev_info(&ams_delta_serio->dev, "%s\n", ams_delta_serio->name);
+        return 0;
+gpio_clk:
+        gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
+gpio_data:
+        gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
+serio:
+        kfree(ams_delta_serio);
+        return err;
+}
+module_init(ams_delta_serio_init);
+static void __exit ams_delta_serio_exit(void)
+{
+        serio_unregister_port(ams_delta_serio);
+        free_irq(OMAP_GPIO_IRQ(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 0);
+        gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
+        gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
+        kfree(ams_delta_serio);
+}
+module_exit(ams_delta_serio_exit);
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 26ac8aad0b19..f084249295d9 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -1678,9 +1678,9 @@ int bitmap_create(mddev_t *mddev)
        bitmap->mddev = mddev;
-        bm = sysfs_get_dirent(mddev->kobj.sd, "bitmap");
+        bm = sysfs_get_dirent(mddev->kobj.sd, NULL, "bitmap");
        if (bm) {
-                bitmap->sysfs_can_clear = sysfs_get_dirent(bm, "can_clear");
+                bitmap->sysfs_can_clear = sysfs_get_dirent(bm, NULL, "can_clear");
                sysfs_put(bm);
        } else
                bitmap->sysfs_can_clear = NULL;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index cefd63daff31..a9fd491796ac 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1766,7 +1766,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
                kobject_del(&rdev->kobj);
                goto fail;
        }
-        rdev->sysfs_state = sysfs_get_dirent(rdev->kobj.sd, "state");
+        rdev->sysfs_state = sysfs_get_dirent(rdev->kobj.sd, NULL, "state");
        list_add_rcu(&rdev->same_set, &mddev->disks);
        bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
@@ -4189,7 +4189,7 @@ static int md_alloc(dev_t dev, char *name)
        mutex_unlock(&disks_mutex);
        if (!error) {
                kobject_uevent(&mddev->kobj, KOBJ_ADD);
-                mddev->sysfs_state = sysfs_get_dirent(mddev->kobj.sd, "array_state");
+                mddev->sysfs_state = sysfs_get_dirent(mddev->kobj.sd, NULL, "array_state");
        }
        mddev_put(mddev);
        return error;
@@ -4398,7 +4398,7 @@ static int do_md_run(mddev_t * mddev)
                        printk(KERN_WARNING
                               "md: cannot register extra attributes for %s\n",
                               mdname(mddev));
-                mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
+                mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
        } else if (mddev->ro == 2) /* auto-readonly not meaningful */
                mddev->ro = 0;
diff --git a/drivers/misc/c2port/core.c b/drivers/misc/c2port/core.c
index ed090e77c9cd..19fc7c1cb428 100644
--- a/drivers/misc/c2port/core.c
+++ b/drivers/misc/c2port/core.c
@@ -707,7 +707,7 @@ static ssize_t __c2port_read_flash_data(struct c2port_device *dev,
        return nread;
 }
-static ssize_t c2port_read_flash_data(struct kobject *kobj,
+static ssize_t c2port_read_flash_data(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *attr,
                                char *buffer, loff_t offset, size_t count)
 {
@@ -824,7 +824,7 @@ static ssize_t __c2port_write_flash_data(struct c2port_device *dev,
        return nwrite;
 }
-static ssize_t c2port_write_flash_data(struct kobject *kobj,
+static ssize_t c2port_write_flash_data(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *attr,
                                char *buffer, loff_t offset, size_t count)
 {
diff --git a/drivers/misc/ds1682.c b/drivers/misc/ds1682.c
index 9197cfc55015..a513f0aa6432 100644
--- a/drivers/misc/ds1682.c
+++ b/drivers/misc/ds1682.c
@@ -140,7 +140,8 @@ static const struct attribute_group ds1682_group = {
 /*
 * User data attribute
 */
-static ssize_t ds1682_eeprom_read(struct kobject *kobj, struct bin_attribute *attr,
+static ssize_t ds1682_eeprom_read(struct file *filp, struct kobject *kobj,
+                                  struct bin_attribute *attr,
                                  char *buf, loff_t off, size_t count)
 {
        struct i2c_client *client = kobj_to_i2c_client(kobj);
@@ -163,7 +164,8 @@ static ssize_t ds1682_eeprom_read(struct kobject *kobj, struct bin_attribute *at
        return count;
 }
-static ssize_t ds1682_eeprom_write(struct kobject *kobj, struct bin_attribute *attr,
+static ssize_t ds1682_eeprom_write(struct file *filp, struct kobject *kobj,
+                                   struct bin_attribute *attr,
                                   char *buf, loff_t off, size_t count)
 {
        struct i2c_client *client = kobj_to_i2c_client(kobj);
diff --git a/drivers/misc/eeprom/at24.c b/drivers/misc/eeprom/at24.c
index db7d0f21b65d..f7ca3a42b490 100644
--- a/drivers/misc/eeprom/at24.c
+++ b/drivers/misc/eeprom/at24.c
@@ -54,7 +54,7 @@
 struct at24_data {
        struct at24_platform_data chip;
        struct memory_accessor macc;
-        bool use_smbus;
+        int use_smbus;
        /*
         * Lock protects against activities from other Linux tasks,
@@ -184,11 +184,19 @@ static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
        if (count > io_limit)
                count = io_limit;
-        if (at24->use_smbus) {
+        switch (at24->use_smbus) {
+        case I2C_SMBUS_I2C_BLOCK_DATA:
                /* Smaller eeproms can work given some SMBus extension calls */
                if (count > I2C_SMBUS_BLOCK_MAX)
                        count = I2C_SMBUS_BLOCK_MAX;
-        } else {
+                break;
+        case I2C_SMBUS_WORD_DATA:
+                count = 2;
+                break;
+        case I2C_SMBUS_BYTE_DATA:
+                count = 1;
+                break;
+        default:
                /*
                 * When we have a better choice than SMBus calls, use a
                 * combined I2C message. Write address; then read up to
@@ -219,10 +227,27 @@ static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
        timeout = jiffies + msecs_to_jiffies(write_timeout);
        do {
                read_time = jiffies;
-                if (at24->use_smbus) {
+                switch (at24->use_smbus) {
+                case I2C_SMBUS_I2C_BLOCK_DATA:
                        status = i2c_smbus_read_i2c_block_data(client, offset,
                                        count, buf);
-                } else {
+                        break;
+                case I2C_SMBUS_WORD_DATA:
+                        status = i2c_smbus_read_word_data(client, offset);
+                        if (status >= 0) {
+                                buf[0] = status & 0xff;
+                                buf[1] = status >> 8;
+                                status = count;
+                        }
+                        break;
+                case I2C_SMBUS_BYTE_DATA:
+                        status = i2c_smbus_read_byte_data(client, offset);
+                        if (status >= 0) {
+                                buf[0] = status;
+                                status = count;
+                        }
+                        break;
+                default:
                        status = i2c_transfer(client->adapter, msg, 2);
                        if (status == 2)
                                status = count;
@@ -274,7 +299,8 @@ static ssize_t at24_read(struct at24_data *at24,
        return retval;
 }
-static ssize_t at24_bin_read(struct kobject *kobj, struct bin_attribute *attr,
+static ssize_t at24_bin_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct at24_data *at24;
@@ -395,7 +421,8 @@ static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
        return retval;
 }
-static ssize_t at24_bin_write(struct kobject *kobj, struct bin_attribute *attr,
+static ssize_t at24_bin_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct at24_data *at24;
@@ -434,7 +461,7 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
        struct at24_platform_data chip;
        bool writable;
-        bool use_smbus = false;
+        int use_smbus = 0;
        struct at24_data *at24;
        int err;
        unsigned i, num_addresses;
@@ -475,12 +502,19 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
                        err = -EPFNOSUPPORT;
                        goto err_out;
                }
-                if (!i2c_check_functionality(client->adapter,
+                if (i2c_check_functionality(client->adapter,
                                I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
+                        use_smbus = I2C_SMBUS_I2C_BLOCK_DATA;
+                } else if (i2c_check_functionality(client->adapter,
+                                I2C_FUNC_SMBUS_READ_WORD_DATA)) {
+                        use_smbus = I2C_SMBUS_WORD_DATA;
+                } else if (i2c_check_functionality(client->adapter,
+                                I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
+                        use_smbus = I2C_SMBUS_BYTE_DATA;
+                } else {
                        err = -EPFNOSUPPORT;
                        goto err_out;
                }
-                use_smbus = true;
        }
        if (chip.flags & AT24_FLAG_TAKE8ADDR)
@@ -566,11 +600,16 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
        dev_info(&client->dev, "%zu byte %s EEPROM %s\n",
                at24->bin.size, client->name,
                writable ? "(writable)" : "(read-only)");
+        if (use_smbus == I2C_SMBUS_WORD_DATA ||
+            use_smbus == I2C_SMBUS_BYTE_DATA) {
+                dev_notice(&client->dev, "Falling back to %s reads, "
+                           "performance will suffer\n", use_smbus ==
+                           I2C_SMBUS_WORD_DATA ? "word" : "byte");
+        }
        dev_dbg(&client->dev,
-                "page_size %d, num_addresses %d, write_max %d%s\n",
+                "page_size %d, num_addresses %d, write_max %d, use_smbus %d\n",
                chip.page_size, num_addresses,
-                at24->write_max,
+                at24->write_max, use_smbus);
-                use_smbus ? ", use_smbus" : "");
        /* export data to kernel code */
        if (chip.setup)
diff --git a/drivers/misc/eeprom/at25.c b/drivers/misc/eeprom/at25.c
index d194212a41f6..c627e4174ccd 100644
--- a/drivers/misc/eeprom/at25.c
+++ b/drivers/misc/eeprom/at25.c
@@ -126,7 +126,8 @@ at25_ee_read(
 }
 static ssize_t
-at25_bin_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+at25_bin_read(struct file *filp, struct kobject *kobj,
+              struct bin_attribute *bin_attr,
              char *buf, loff_t off, size_t count)
 {
        struct device           *dev;
@@ -253,7 +254,8 @@ at25_ee_write(struct at25_data *at25, const char *buf, loff_t off,
 }
 static ssize_t
-at25_bin_write(struct kobject *kobj, struct bin_attribute *bin_attr,
+at25_bin_write(struct file *filp, struct kobject *kobj,
+               struct bin_attribute *bin_attr,
               char *buf, loff_t off, size_t count)
 {
        struct device           *dev;
diff --git a/drivers/misc/eeprom/eeprom.c b/drivers/misc/eeprom/eeprom.c
index e306a8cd2f96..45060ddc4e59 100644
--- a/drivers/misc/eeprom/eeprom.c
+++ b/drivers/misc/eeprom/eeprom.c
@@ -81,7 +81,8 @@ exit:
        mutex_unlock(&data->update_lock);
 }
-static ssize_t eeprom_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+static ssize_t eeprom_read(struct file *filp, struct kobject *kobj,
+                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
 {
        struct i2c_client *client = to_i2c_client(container_of(kobj, struct device, kobj));
diff --git a/drivers/misc/eeprom/max6875.c b/drivers/misc/eeprom/max6875.c
index fe2909278507..5653a3ce0517 100644
--- a/drivers/misc/eeprom/max6875.c
+++ b/drivers/misc/eeprom/max6875.c
@@ -107,7 +107,7 @@ exit_up:
        mutex_unlock(&data->update_lock);
 }
-static ssize_t max6875_read(struct kobject *kobj,
+static ssize_t max6875_read(struct file *filp, struct kobject *kobj,
                            struct bin_attribute *bin_attr,
                            char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/net/mlx4/mlx4.h b/drivers/net/mlx4/mlx4.h
index bc72d6e4919b..13343e884999 100644
--- a/drivers/net/mlx4/mlx4.h
+++ b/drivers/net/mlx4/mlx4.h
@@ -40,6 +40,7 @@
 #include <linux/mutex.h>
 #include <linux/radix-tree.h>
 #include <linux/timer.h>
+#include <linux/semaphore.h>
 #include <linux/workqueue.h>
 #include <linux/mlx4/device.h>
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index c61a61f177b7..6ce6ce1df6d2 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -2560,7 +2560,8 @@ netxen_sysfs_validate_crb(struct netxen_adapter *adapter,
 }
 static ssize_t
-netxen_sysfs_read_crb(struct kobject *kobj, struct bin_attribute *attr,
+netxen_sysfs_read_crb(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -2587,7 +2588,8 @@ netxen_sysfs_read_crb(struct kobject *kobj, struct bin_attribute *attr,
 }
 static ssize_t
-netxen_sysfs_write_crb(struct kobject *kobj, struct bin_attribute *attr,
+netxen_sysfs_write_crb(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -2627,7 +2629,8 @@ netxen_sysfs_validate_mem(struct netxen_adapter *adapter,
 }
 static ssize_t
-netxen_sysfs_read_mem(struct kobject *kobj, struct bin_attribute *attr,
+netxen_sysfs_read_mem(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -2647,7 +2650,7 @@ netxen_sysfs_read_mem(struct kobject *kobj, struct bin_attribute *attr,
        return size;
 }
-static ssize_t netxen_sysfs_write_mem(struct kobject *kobj,
+static ssize_t netxen_sysfs_write_mem(struct file *filp, struct kobject *kobj,
                struct bin_attribute *attr, char *buf,
                loff_t offset, size_t size)
 {
diff --git a/drivers/net/qlcnic/qlcnic_main.c b/drivers/net/qlcnic/qlcnic_main.c
index 1003eb76fda3..23ea9caa5261 100644
--- a/drivers/net/qlcnic/qlcnic_main.c
+++ b/drivers/net/qlcnic/qlcnic_main.c
@@ -2464,7 +2464,8 @@ qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
 }
 static ssize_t
-qlcnic_sysfs_read_crb(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -2488,7 +2489,8 @@ qlcnic_sysfs_read_crb(struct kobject *kobj, struct bin_attribute *attr,
 }
 static ssize_t
-qlcnic_sysfs_write_crb(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -2525,7 +2527,8 @@ qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
 }
 static ssize_t
-qlcnic_sysfs_read_mem(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -2546,7 +2549,8 @@ qlcnic_sysfs_read_mem(struct kobject *kobj, struct bin_attribute *attr,
 }
 static ssize_t
-qlcnic_sysfs_write_mem(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t offset, size_t size)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
diff --git a/drivers/pci/hotplug/acpiphp_ibm.c b/drivers/pci/hotplug/acpiphp_ibm.c
index 6ecbfb27db9d..e525263210ee 100644
--- a/drivers/pci/hotplug/acpiphp_ibm.c
+++ b/drivers/pci/hotplug/acpiphp_ibm.c
@@ -108,7 +108,7 @@ static int ibm_set_attention_status(struct hotplug_slot *slot, u8 status);
 static int ibm_get_attention_status(struct hotplug_slot *slot, u8 *status);
 static void ibm_handle_events(acpi_handle handle, u32 event, void *context);
 static int ibm_get_table_from_acpi(char **bufp);
-static ssize_t ibm_read_apci_table(struct kobject *kobj,
+static ssize_t ibm_read_apci_table(struct file *filp, struct kobject *kobj,
                                   struct bin_attribute *bin_attr,
                                   char *buffer, loff_t pos, size_t size);
 static acpi_status __init ibm_find_acpi_device(acpi_handle handle,
@@ -351,6 +351,7 @@ read_table_done:
 /**
 * ibm_read_apci_table - callback for the sysfs apci_table file
+ * @filp: the open sysfs file
 * @kobj: the kobject this binary attribute is a part of
 * @bin_attr: struct bin_attribute for this file
 * @buffer: the kernel space buffer to fill
@@ -364,7 +365,7 @@ read_table_done:
 * things get really tricky here...
 * our solution is to only allow reading the table in all at once.
 */
-static ssize_t ibm_read_apci_table(struct kobject *kobj,
+static ssize_t ibm_read_apci_table(struct file *filp, struct kobject *kobj,
                                   struct bin_attribute *bin_attr,
                                   char *buffer, loff_t pos, size_t size)
 {
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index fad93983bfed..6309c5a2528f 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -21,6 +21,7 @@
 #include <linux/stat.h>
 #include <linux/topology.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/capability.h>
 #include <linux/pci-aspm.h>
 #include <linux/slab.h>
@@ -357,7 +358,8 @@ boot_vga_show(struct device *dev, struct device_attribute *attr, char *buf)
 struct device_attribute vga_attr = __ATTR_RO(boot_vga);
 static ssize_t
-pci_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
+pci_read_config(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *bin_attr,
                char *buf, loff_t off, size_t count)
 {
        struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
@@ -366,7 +368,7 @@ pci_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
        u8 *data = (u8*) buf;
        /* Several chips lock up trying to read undefined config space */
-        if (capable(CAP_SYS_ADMIN)) {
+        if (cap_raised(filp->f_cred->cap_effective, CAP_SYS_ADMIN)) {
                size = dev->cfg_size;
        } else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
                size = 128;
@@ -430,7 +432,8 @@ pci_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
 }
 static ssize_t
-pci_write_config(struct kobject *kobj, struct bin_attribute *bin_attr,
+pci_write_config(struct file* filp, struct kobject *kobj,
+                 struct bin_attribute *bin_attr,
                 char *buf, loff_t off, size_t count)
 {
        struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
@@ -487,7 +490,8 @@ pci_write_config(struct kobject *kobj, struct bin_attribute *bin_attr,
 }
 static ssize_t
-read_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
+read_vpd_attr(struct file *filp, struct kobject *kobj,
+              struct bin_attribute *bin_attr,
              char *buf, loff_t off, size_t count)
 {
        struct pci_dev *dev =
@@ -502,7 +506,8 @@ read_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
 }
 static ssize_t
-write_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
+write_vpd_attr(struct file *filp, struct kobject *kobj,
+               struct bin_attribute *bin_attr,
               char *buf, loff_t off, size_t count)
 {
        struct pci_dev *dev =
@@ -519,6 +524,7 @@ write_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
 #ifdef HAVE_PCI_LEGACY
 /**
 * pci_read_legacy_io - read byte(s) from legacy I/O port space
+ * @filp: open sysfs file
 * @kobj: kobject corresponding to file to read from
 * @bin_attr: struct bin_attribute for this file
 * @buf: buffer to store results
@@ -529,7 +535,8 @@ write_vpd_attr(struct kobject *kobj, struct bin_attribute *bin_attr,
 * callback routine (pci_legacy_read).
 */
 static ssize_t
-pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
+pci_read_legacy_io(struct file *filp, struct kobject *kobj,
+                   struct bin_attribute *bin_attr,
                   char *buf, loff_t off, size_t count)
 {
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
@@ -545,6 +552,7 @@ pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
 /**
 * pci_write_legacy_io - write byte(s) to legacy I/O port space
+ * @filp: open sysfs file
 * @kobj: kobject corresponding to file to read from
 * @bin_attr: struct bin_attribute for this file
 * @buf: buffer containing value to be written
@@ -555,7 +563,8 @@ pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
 * callback routine (pci_legacy_write).
 */
 static ssize_t
-pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
+pci_write_legacy_io(struct file *filp, struct kobject *kobj,
+                    struct bin_attribute *bin_attr,
                    char *buf, loff_t off, size_t count)
 {
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
@@ -570,6 +579,7 @@ pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
 /**
 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
+ * @filp: open sysfs file
 * @kobj: kobject corresponding to device to be mapped
 * @attr: struct bin_attribute for this file
 * @vma: struct vm_area_struct passed to mmap
@@ -579,7 +589,8 @@ pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
 * memory space.
 */
 static int
-pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
+pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
+                    struct bin_attribute *attr,
                    struct vm_area_struct *vma)
 {
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
@@ -591,6 +602,7 @@ pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
 /**
 * pci_mmap_legacy_io - map legacy PCI IO into user memory space
+ * @filp: open sysfs file
 * @kobj: kobject corresponding to device to be mapped
 * @attr: struct bin_attribute for this file
 * @vma: struct vm_area_struct passed to mmap
@@ -600,7 +612,8 @@ pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
 * memory space. Returns -ENOSYS if the operation isn't supported
 */
 static int
-pci_mmap_legacy_io(struct kobject *kobj, struct bin_attribute *attr,
+pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
+                   struct bin_attribute *attr,
                   struct vm_area_struct *vma)
 {
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
@@ -750,14 +763,16 @@ pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
 }
 static int
-pci_mmap_resource_uc(struct kobject *kobj, struct bin_attribute *attr,
+pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
+                     struct bin_attribute *attr,
                     struct vm_area_struct *vma)
 {
        return pci_mmap_resource(kobj, attr, vma, 0);
 }
 static int
-pci_mmap_resource_wc(struct kobject *kobj, struct bin_attribute *attr,
+pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
+                     struct bin_attribute *attr,
                     struct vm_area_struct *vma)
 {
        return pci_mmap_resource(kobj, attr, vma, 1);
@@ -861,6 +876,7 @@ void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
 /**
 * pci_write_rom - used to enable access to the PCI ROM display
+ * @filp: sysfs file
 * @kobj: kernel object handle
 * @bin_attr: struct bin_attribute for this file
 * @buf: user input
@@ -870,7 +886,8 @@ void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
 * writing anything except 0 enables it
 */
 static ssize_t
-pci_write_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
+pci_write_rom(struct file *filp, struct kobject *kobj,
+              struct bin_attribute *bin_attr,
              char *buf, loff_t off, size_t count)
 {
        struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
@@ -885,6 +902,7 @@ pci_write_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
 /**
 * pci_read_rom - read a PCI ROM
+ * @filp: sysfs file
 * @kobj: kernel object handle
 * @bin_attr: struct bin_attribute for this file
 * @buf: where to put the data we read from the ROM
@@ -895,7 +913,8 @@ pci_write_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
 * device corresponding to @kobj.
 */
 static ssize_t
-pci_read_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
+pci_read_rom(struct file *filp, struct kobject *kobj,
+             struct bin_attribute *bin_attr,
             char *buf, loff_t off, size_t count)
 {
        struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
diff --git a/drivers/pcmcia/cistpl.c b/drivers/pcmcia/cistpl.c
index 60d428be0b07..8844bc3e3118 100644
--- a/drivers/pcmcia/cistpl.c
+++ b/drivers/pcmcia/cistpl.c
@@ -1531,7 +1531,7 @@ static ssize_t pccard_extract_cis(struct pcmcia_socket *s, char *buf,
 }
-static ssize_t pccard_show_cis(struct kobject *kobj,
+static ssize_t pccard_show_cis(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
@@ -1562,7 +1562,7 @@ static ssize_t pccard_show_cis(struct kobject *kobj,
 }
-static ssize_t pccard_store_cis(struct kobject *kobj,
+static ssize_t pccard_store_cis(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/power/olpc_battery.c b/drivers/power/olpc_battery.c
index 8fefe5a73558..baefcf1cffc9 100644
--- a/drivers/power/olpc_battery.c
+++ b/drivers/power/olpc_battery.c
@@ -354,7 +354,7 @@ static enum power_supply_property olpc_bat_props[] = {
 #define EEPROM_END      0x80
 #define EEPROM_SIZE     (EEPROM_END - EEPROM_START)
-static ssize_t olpc_bat_eeprom_read(struct kobject *kobj,
+static ssize_t olpc_bat_eeprom_read(struct file *filp, struct kobject *kobj,
                struct bin_attribute *attr, char *buf, loff_t off, size_t count)
 {
        uint8_t ec_byte;
diff --git a/drivers/rapidio/rio-sysfs.c b/drivers/rapidio/rio-sysfs.c
index ba742e82c57d..00b475658356 100644
--- a/drivers/rapidio/rio-sysfs.c
+++ b/drivers/rapidio/rio-sysfs.c
@@ -68,7 +68,8 @@ struct device_attribute rio_dev_attrs[] = {
 };
 static ssize_t
-rio_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
+rio_read_config(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *bin_attr,
                char *buf, loff_t off, size_t count)
 {
        struct rio_dev *dev =
@@ -139,7 +140,8 @@ rio_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
 }
 static ssize_t
-rio_write_config(struct kobject *kobj, struct bin_attribute *bin_attr,
+rio_write_config(struct file *filp, struct kobject *kobj,
+                 struct bin_attribute *bin_attr,
                 char *buf, loff_t off, size_t count)
 {
        struct rio_dev *dev =
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index e9aa814ddd23..ece4dbddc0ea 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -519,7 +519,8 @@ static const struct rtc_class_ops cmos_rtc_ops = {
 #define NVRAM_OFFSET    (RTC_REG_D + 1)
 static ssize_t
-cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+cmos_nvram_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        int     retval;
@@ -547,7 +548,8 @@ cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 }
 static ssize_t
-cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+cmos_nvram_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct cmos_rtc *cmos;
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index 7836c9cec557..48da85e97ca4 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -542,7 +542,8 @@ static void msg_init(struct spi_message *m, struct spi_transfer *x,
 }
 static ssize_t
-ds1305_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+ds1305_nvram_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct spi_device       *spi;
@@ -572,7 +573,8 @@ ds1305_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 }
 static ssize_t
-ds1305_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+ds1305_nvram_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct spi_device       *spi;
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index c4ec5c158aa1..de033b7ac21f 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -556,7 +556,8 @@ static const struct rtc_class_ops ds13xx_rtc_ops = {
 #define NVRAM_SIZE      56
 static ssize_t
-ds1307_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
+ds1307_nvram_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct i2c_client       *client;
@@ -580,7 +581,8 @@ ds1307_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 }
 static ssize_t
-ds1307_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
+ds1307_nvram_write(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct i2c_client       *client;
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 06b8566c4532..37268e97de49 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -423,8 +423,9 @@ static const struct rtc_class_ops ds1511_rtc_ops = {
 };
 static ssize_t
-ds1511_nvram_read(struct kobject *kobj, struct bin_attribute *ba,
+ds1511_nvram_read(struct file *filp, struct kobject *kobj,
-                                char *buf, loff_t pos, size_t size)
+                  struct bin_attribute *ba,
+                  char *buf, loff_t pos, size_t size)
 {
        ssize_t count;
@@ -452,8 +453,9 @@ ds1511_nvram_read(struct kobject *kobj, struct bin_attribute *ba,
 }
 static ssize_t
-ds1511_nvram_write(struct kobject *kobj, struct bin_attribute *bin_attr,
+ds1511_nvram_write(struct file *filp, struct kobject *kobj,
-                                char *buf, loff_t pos, size_t size)
+                   struct bin_attribute *bin_attr,
+                   char *buf, loff_t pos, size_t size)
 {
        ssize_t count;
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index 244f9994bcbb..ff432e2ca275 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -252,7 +252,7 @@ static const struct rtc_class_ops ds1553_rtc_ops = {
        .update_irq_enable      = ds1553_rtc_update_irq_enable,
 };
-static ssize_t ds1553_nvram_read(struct kobject *kobj,
+static ssize_t ds1553_nvram_read(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t pos, size_t size)
 {
@@ -267,7 +267,7 @@ static ssize_t ds1553_nvram_read(struct kobject *kobj,
        return count;
 }
-static ssize_t ds1553_nvram_write(struct kobject *kobj,
+static ssize_t ds1553_nvram_write(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *buf, loff_t pos, size_t size)
 {
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 2b4b0bc42d6f..042630c90dd3 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -128,7 +128,7 @@ static const struct rtc_class_ops ds1742_rtc_ops = {
        .set_time       = ds1742_rtc_set_time,
 };
-static ssize_t ds1742_nvram_read(struct kobject *kobj,
+static ssize_t ds1742_nvram_read(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t pos, size_t size)
 {
@@ -143,7 +143,7 @@ static ssize_t ds1742_nvram_read(struct kobject *kobj,
        return count;
 }
-static ssize_t ds1742_nvram_write(struct kobject *kobj,
+static ssize_t ds1742_nvram_write(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *buf, loff_t pos, size_t size)
 {
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index 365ff3ac2348..be8359fdb65a 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -343,7 +343,7 @@ static const struct rtc_class_ops m48t02_rtc_ops = {
        .set_time       = m48t59_rtc_set_time,
 };
-static ssize_t m48t59_nvram_read(struct kobject *kobj,
+static ssize_t m48t59_nvram_read(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t pos, size_t size)
 {
@@ -363,7 +363,7 @@ static ssize_t m48t59_nvram_read(struct kobject *kobj,
        return cnt;
 }
-static ssize_t m48t59_nvram_write(struct kobject *kobj,
+static ssize_t m48t59_nvram_write(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t pos, size_t size)
 {
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index b53a00198dbe..3b943673cd3e 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -244,7 +244,7 @@ static const struct rtc_class_ops stk17ta8_rtc_ops = {
        .alarm_irq_enable       = stk17ta8_rtc_alarm_irq_enable,
 };
-static ssize_t stk17ta8_nvram_read(struct kobject *kobj,
+static ssize_t stk17ta8_nvram_read(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *attr, char *buf,
                                 loff_t pos, size_t size)
 {
@@ -259,7 +259,7 @@ static ssize_t stk17ta8_nvram_read(struct kobject *kobj,
        return count;
 }
-static ssize_t stk17ta8_nvram_write(struct kobject *kobj,
+static ssize_t stk17ta8_nvram_write(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *attr, char *buf,
                                  loff_t pos, size_t size)
 {
diff --git a/drivers/rtc/rtc-tx4939.c b/drivers/rtc/rtc-tx4939.c
index 20bfc64a15c8..ec6313d15359 100644
--- a/drivers/rtc/rtc-tx4939.c
+++ b/drivers/rtc/rtc-tx4939.c
@@ -188,7 +188,7 @@ static const struct rtc_class_ops tx4939_rtc_ops = {
        .alarm_irq_enable       = tx4939_rtc_alarm_irq_enable,
 };
-static ssize_t tx4939_rtc_nvram_read(struct kobject *kobj,
+static ssize_t tx4939_rtc_nvram_read(struct file *filp, struct kobject *kobj,
                                     struct bin_attribute *bin_attr,
                                     char *buf, loff_t pos, size_t size)
 {
@@ -207,7 +207,7 @@ static ssize_t tx4939_rtc_nvram_read(struct kobject *kobj,
        return count;
 }
-static ssize_t tx4939_rtc_nvram_write(struct kobject *kobj,
+static ssize_t tx4939_rtc_nvram_write(struct file *filp, struct kobject *kobj,
                                      struct bin_attribute *bin_attr,
                                      char *buf, loff_t pos, size_t size)
 {
diff --git a/drivers/s390/cio/chp.c b/drivers/s390/cio/chp.c
index 1d16189f2f2d..6c9fa15aac7b 100644
--- a/drivers/s390/cio/chp.c
+++ b/drivers/s390/cio/chp.c
@@ -135,7 +135,8 @@ static int s390_vary_chpid(struct chp_id chpid, int on)
 /*
 * Channel measurement related functions
 */
-static ssize_t chp_measurement_chars_read(struct kobject *kobj,
+static ssize_t chp_measurement_chars_read(struct file *filp,
+                                          struct kobject *kobj,
                                          struct bin_attribute *bin_attr,
                                          char *buf, loff_t off, size_t count)
 {
@@ -182,7 +183,7 @@ static void chp_measurement_copy_block(struct cmg_entry *buf,
        } while (reference_buf.values[0] != buf->values[0]);
 }
-static ssize_t chp_measurement_read(struct kobject *kobj,
+static ssize_t chp_measurement_read(struct file *filp, struct kobject *kobj,
                                    struct bin_attribute *bin_attr,
                                    char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
index 54c5ffb1eaa1..d38000db9237 100644
--- a/drivers/scsi/3w-sas.c
+++ b/drivers/scsi/3w-sas.c
@@ -98,7 +98,7 @@ static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_res
 /* Functions */
 /* This function returns AENs through sysfs */
-static ssize_t twl_sysfs_aen_read(struct kobject *kobj,
+static ssize_t twl_sysfs_aen_read(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *outbuf, loff_t offset, size_t count)
 {
@@ -129,7 +129,7 @@ static struct bin_attribute twl_sysfs_aen_read_attr = {
 };
 /* This function returns driver compatibility info through sysfs */
-static ssize_t twl_sysfs_compat_info(struct kobject *kobj,
+static ssize_t twl_sysfs_compat_info(struct file *filp, struct kobject *kobj,
                                     struct bin_attribute *bin_attr,
                                     char *outbuf, loff_t offset, size_t count)
 {
diff --git a/drivers/scsi/arcmsr/arcmsr_attr.c b/drivers/scsi/arcmsr/arcmsr_attr.c
index 5877f29a6005..a4e04c50c436 100644
--- a/drivers/scsi/arcmsr/arcmsr_attr.c
+++ b/drivers/scsi/arcmsr/arcmsr_attr.c
@@ -59,7 +59,8 @@
 struct device_attribute *arcmsr_host_attrs[];
-static ssize_t arcmsr_sysfs_iop_message_read(struct kobject *kobj,
+static ssize_t arcmsr_sysfs_iop_message_read(struct file *filp,
+                                             struct kobject *kobj,
                                             struct bin_attribute *bin,
                                             char *buf, loff_t off,
                                             size_t count)
@@ -105,7 +106,8 @@ static ssize_t arcmsr_sysfs_iop_message_read(struct kobject *kobj,
        return (allxfer_len);
 }
-static ssize_t arcmsr_sysfs_iop_message_write(struct kobject *kobj,
+static ssize_t arcmsr_sysfs_iop_message_write(struct file *filp,
+                                              struct kobject *kobj,
                                              struct bin_attribute *bin,
                                              char *buf, loff_t off,
                                              size_t count)
@@ -153,7 +155,8 @@ static ssize_t arcmsr_sysfs_iop_message_write(struct kobject *kobj,
        }
 }
-static ssize_t arcmsr_sysfs_iop_message_clear(struct kobject *kobj,
+static ssize_t arcmsr_sysfs_iop_message_clear(struct file *filp,
+                                              struct kobject *kobj,
                                              struct bin_attribute *bin,
                                              char *buf, loff_t off,
                                              size_t count)
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index d18f45c95639..3eb2b7b3d8b0 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -2919,6 +2919,7 @@ static DEVICE_ATTR(log_level, S_IRUGO | S_IWUSR,
 #ifdef CONFIG_SCSI_IBMVFC_TRACE
 /**
 * ibmvfc_read_trace - Dump the adapter trace
+ * @filp:               open sysfs file
 * @kobj:               kobject struct
 * @bin_attr:   bin_attribute struct
 * @buf:                buffer
@@ -2928,7 +2929,7 @@ static DEVICE_ATTR(log_level, S_IRUGO | S_IWUSR,
 * Return value:
 *      number of bytes printed to buffer
 **/
-static ssize_t ibmvfc_read_trace(struct kobject *kobj,
+static ssize_t ibmvfc_read_trace(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index b90c118119d7..6a6661c35b2f 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -3120,6 +3120,7 @@ restart:
 #ifdef CONFIG_SCSI_IPR_TRACE
 /**
 * ipr_read_trace - Dump the adapter trace
+ * @filp:               open sysfs file
 * @kobj:               kobject struct
 * @bin_attr:           bin_attribute struct
 * @buf:                buffer
@@ -3129,7 +3130,7 @@ restart:
 * Return value:
 *      number of bytes printed to buffer
 **/
-static ssize_t ipr_read_trace(struct kobject *kobj,
+static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
                              struct bin_attribute *bin_attr,
                              char *buf, loff_t off, size_t count)
 {
@@ -3764,6 +3765,7 @@ static struct device_attribute *ipr_ioa_attrs[] = {
 #ifdef CONFIG_SCSI_IPR_DUMP
 /**
 * ipr_read_dump - Dump the adapter
+ * @filp:               open sysfs file
 * @kobj:               kobject struct
 * @bin_attr:           bin_attribute struct
 * @buf:                buffer
@@ -3773,7 +3775,7 @@ static struct device_attribute *ipr_ioa_attrs[] = {
 * Return value:
 *      number of bytes printed to buffer
 **/
-static ssize_t ipr_read_dump(struct kobject *kobj,
+static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
                             struct bin_attribute *bin_attr,
                             char *buf, loff_t off, size_t count)
 {
@@ -3927,6 +3929,7 @@ static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
 /**
 * ipr_write_dump - Setup dump state of adapter
+ * @filp:               open sysfs file
 * @kobj:               kobject struct
 * @bin_attr:           bin_attribute struct
 * @buf:                buffer
@@ -3936,7 +3939,7 @@ static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
 * Return value:
 *      number of bytes printed to buffer
 **/
-static ssize_t ipr_write_dump(struct kobject *kobj,
+static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
                              struct bin_attribute *bin_attr,
                              char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 2e5f376d9ccc..bf33b315f93e 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -2643,6 +2643,7 @@ static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
 /**
 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
+ * @filp: sysfs file
 * @kobj: Pointer to the kernel object
 * @bin_attr: Attribute object
 * @buff: Buffer pointer
@@ -2654,7 +2655,8 @@ static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
 * applications.
 **/
 static ssize_t
-sysfs_drvr_stat_data_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *bin_attr,
                char *buf, loff_t off, size_t count)
 {
        struct device *dev = container_of(kobj, struct device,
@@ -3362,6 +3364,7 @@ struct device_attribute *lpfc_vport_attrs[] = {
 /**
 * sysfs_ctlreg_write - Write method for writing to ctlreg
+ * @filp: open sysfs file
 * @kobj: kernel kobject that contains the kernel class device.
 * @bin_attr: kernel attributes passed to us.
 * @buf: contains the data to be written to the adapter IOREG space.
@@ -3379,7 +3382,8 @@ struct device_attribute *lpfc_vport_attrs[] = {
 * value of count, buf contents written
 **/
 static ssize_t
-sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
+sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
+                   struct bin_attribute *bin_attr,
                   char *buf, loff_t off, size_t count)
 {
        size_t buf_off;
@@ -3415,6 +3419,7 @@ sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
 /**
 * sysfs_ctlreg_read - Read method for reading from ctlreg
+ * @filp: open sysfs file
 * @kobj: kernel kobject that contains the kernel class device.
 * @bin_attr: kernel attributes passed to us.
 * @buf: if successful contains the data from the adapter IOREG space.
@@ -3431,7 +3436,8 @@ sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
 * value of count, buf contents read
 **/
 static ssize_t
-sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
+                  struct bin_attribute *bin_attr,
                  char *buf, loff_t off, size_t count)
 {
        size_t buf_off;
@@ -3496,6 +3502,7 @@ sysfs_mbox_idle(struct lpfc_hba *phba)
 /**
 * sysfs_mbox_write - Write method for writing information via mbox
+ * @filp: open sysfs file
 * @kobj: kernel kobject that contains the kernel class device.
 * @bin_attr: kernel attributes passed to us.
 * @buf: contains the data to be written to sysfs mbox.
@@ -3516,7 +3523,8 @@ sysfs_mbox_idle(struct lpfc_hba *phba)
 * count number of bytes transferred
 **/
 static ssize_t
-sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
+sysfs_mbox_write(struct file *filp, struct kobject *kobj,
+                 struct bin_attribute *bin_attr,
                 char *buf, loff_t off, size_t count)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
@@ -3571,6 +3579,7 @@ sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
 /**
 * sysfs_mbox_read - Read method for reading information via mbox
+ * @filp: open sysfs file
 * @kobj: kernel kobject that contains the kernel class device.
 * @bin_attr: kernel attributes passed to us.
 * @buf: contains the data to be read from sysfs mbox.
@@ -3593,7 +3602,8 @@ sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
 * count number of bytes transferred
 **/
 static ssize_t
-sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
+sysfs_mbox_read(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *bin_attr,
                char *buf, loff_t off, size_t count)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 3b708606b932..1e4cafabba15 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -16,7 +16,7 @@ static int qla24xx_vport_disable(struct fc_vport *, bool);
 /* SYSFS attributes --------------------------------------------------------- */
 static ssize_t
-qla2x00_sysfs_read_fw_dump(struct kobject *kobj,
+qla2x00_sysfs_read_fw_dump(struct file *filp, struct kobject *kobj,
                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
 {
@@ -32,7 +32,7 @@ qla2x00_sysfs_read_fw_dump(struct kobject *kobj,
 }
 static ssize_t
-qla2x00_sysfs_write_fw_dump(struct kobject *kobj,
+qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
                            struct bin_attribute *bin_attr,
                            char *buf, loff_t off, size_t count)
 {
@@ -92,7 +92,7 @@ static struct bin_attribute sysfs_fw_dump_attr = {
 };
 static ssize_t
-qla2x00_sysfs_read_nvram(struct kobject *kobj,
+qla2x00_sysfs_read_nvram(struct file *filp, struct kobject *kobj,
                         struct bin_attribute *bin_attr,
                         char *buf, loff_t off, size_t count)
 {
@@ -111,7 +111,7 @@ qla2x00_sysfs_read_nvram(struct kobject *kobj,
 }
 static ssize_t
-qla2x00_sysfs_write_nvram(struct kobject *kobj,
+qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj,
                          struct bin_attribute *bin_attr,
                          char *buf, loff_t off, size_t count)
 {
@@ -177,7 +177,7 @@ static struct bin_attribute sysfs_nvram_attr = {
 };
 static ssize_t
-qla2x00_sysfs_read_optrom(struct kobject *kobj,
+qla2x00_sysfs_read_optrom(struct file *filp, struct kobject *kobj,
                          struct bin_attribute *bin_attr,
                          char *buf, loff_t off, size_t count)
 {
@@ -193,7 +193,7 @@ qla2x00_sysfs_read_optrom(struct kobject *kobj,
 }
 static ssize_t
-qla2x00_sysfs_write_optrom(struct kobject *kobj,
+qla2x00_sysfs_write_optrom(struct file *filp, struct kobject *kobj,
                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
 {
@@ -224,7 +224,7 @@ static struct bin_attribute sysfs_optrom_attr = {
 };
 static ssize_t
-qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj,
+qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
@@ -387,7 +387,7 @@ static struct bin_attribute sysfs_optrom_ctl_attr = {
 };
 static ssize_t
-qla2x00_sysfs_read_vpd(struct kobject *kobj,
+qla2x00_sysfs_read_vpd(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
 {
@@ -408,7 +408,7 @@ qla2x00_sysfs_read_vpd(struct kobject *kobj,
 }
 static ssize_t
-qla2x00_sysfs_write_vpd(struct kobject *kobj,
+qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
 {
@@ -461,7 +461,7 @@ static struct bin_attribute sysfs_vpd_attr = {
 };
 static ssize_t
-qla2x00_sysfs_read_sfp(struct kobject *kobj,
+qla2x00_sysfs_read_sfp(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
 {
@@ -522,7 +522,7 @@ static struct bin_attribute sysfs_sfp_attr = {
 };
 static ssize_t
-qla2x00_sysfs_write_reset(struct kobject *kobj,
+qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
 {
@@ -592,7 +592,7 @@ static struct bin_attribute sysfs_reset_attr = {
 };
 static ssize_t
-qla2x00_sysfs_write_edc(struct kobject *kobj,
+qla2x00_sysfs_write_edc(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
 {
@@ -650,7 +650,7 @@ static struct bin_attribute sysfs_edc_attr = {
 };
 static ssize_t
-qla2x00_sysfs_write_edc_status(struct kobject *kobj,
+qla2x00_sysfs_write_edc_status(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
 {
@@ -700,7 +700,7 @@ qla2x00_sysfs_write_edc_status(struct kobject *kobj,
 }
 static ssize_t
-qla2x00_sysfs_read_edc_status(struct kobject *kobj,
+qla2x00_sysfs_read_edc_status(struct file *filp, struct kobject *kobj,
                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
 {
@@ -730,7 +730,7 @@ static struct bin_attribute sysfs_edc_status_attr = {
 };
 static ssize_t
-qla2x00_sysfs_read_xgmac_stats(struct kobject *kobj,
+qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
 {
@@ -782,7 +782,7 @@ static struct bin_attribute sysfs_xgmac_stats_attr = {
 };
 static ssize_t
-qla2x00_sysfs_read_dcbx_tlv(struct kobject *kobj,
+qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 302836a80693..8b23165bc5dc 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -1423,8 +1423,8 @@ config SERIAL_SC26XX_CONSOLE
          Support for Console on SC2681/SC2692 serial ports.
 config SERIAL_BFIN_SPORT
-        tristate "Blackfin SPORT emulate UART (EXPERIMENTAL)"
+        tristate "Blackfin SPORT emulate UART"
-        depends on BLACKFIN && EXPERIMENTAL
+        depends on BLACKFIN
        select SERIAL_CORE
        help
          Enable SPORT emulate UART on Blackfin series.
@@ -1439,28 +1439,52 @@ config SERIAL_BFIN_SPORT_CONSOLE
 config SERIAL_BFIN_SPORT0_UART
        bool "Enable UART over SPORT0"
-        depends on SERIAL_BFIN_SPORT && !(BF542 || BF542M || BF544 || BF544M)
+        depends on SERIAL_BFIN_SPORT && !(BF542 || BF544)
        help
          Enable UART over SPORT0
+config SERIAL_BFIN_SPORT0_UART_CTSRTS
+        bool "Enable UART over SPORT0 hardware flow control"
+        depends on SERIAL_BFIN_SPORT0_UART
+        help
+          Enable hardware flow control in the driver.
 config SERIAL_BFIN_SPORT1_UART
        bool "Enable UART over SPORT1"
        depends on SERIAL_BFIN_SPORT
        help
          Enable UART over SPORT1
+config SERIAL_BFIN_SPORT1_UART_CTSRTS
+        bool "Enable UART over SPORT1 hardware flow control"
+        depends on SERIAL_BFIN_SPORT1_UART
+        help
+          Enable hardware flow control in the driver.
 config SERIAL_BFIN_SPORT2_UART
        bool "Enable UART over SPORT2"
        depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
        help
          Enable UART over SPORT2
+config SERIAL_BFIN_SPORT2_UART_CTSRTS
+        bool "Enable UART over SPORT2 hardware flow control"
+        depends on SERIAL_BFIN_SPORT2_UART
+        help
+          Enable hardware flow control in the driver.
 config SERIAL_BFIN_SPORT3_UART
        bool "Enable UART over SPORT3"
        depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
        help
          Enable UART over SPORT3
+config SERIAL_BFIN_SPORT3_UART_CTSRTS
+        bool "Enable UART over SPORT3 hardware flow control"
+        depends on SERIAL_BFIN_SPORT3_UART
+        help
+          Enable hardware flow control in the driver.
 config SERIAL_TIMBERDALE
        tristate "Support for timberdale UART"
        select SERIAL_CORE
@@ -1499,4 +1523,56 @@ config SERIAL_GRLIB_GAISLER_APBUART_CONSOLE
        help
        Support for running a console on the GRLIB APBUART
+config SERIAL_ALTERA_JTAGUART
+        tristate "Altera JTAG UART support"
+        select SERIAL_CORE
+        help
+          This driver supports the Altera JTAG UART port.
+config SERIAL_ALTERA_JTAGUART_CONSOLE
+        bool "Altera JTAG UART console support"
+        depends on SERIAL_ALTERA_JTAGUART=y
+        select SERIAL_CORE_CONSOLE
+        help
+          Enable a Altera JTAG UART port to be the system console.
+config SERIAL_ALTERA_JTAGUART_CONSOLE_BYPASS
+        bool "Bypass output when no connection"
+        depends on SERIAL_ALTERA_JTAGUART_CONSOLE
+        select SERIAL_CORE_CONSOLE
+        help
+          Bypass console output and keep going even if there is no
+          JTAG terminal connection with the host.
+config SERIAL_ALTERA_UART
+        tristate "Altera UART support"
+        select SERIAL_CORE
+        help
+          This driver supports the Altera softcore UART port.
+config SERIAL_ALTERA_UART_MAXPORTS
+        int "Maximum number of Altera UART ports"
+        depends on SERIAL_ALTERA_UART
+        default 4
+        help
+          This setting lets you define the maximum number of the Altera
+          UART ports. The usual default varies from board to board, and
+          this setting is a way of catering for that.
+config SERIAL_ALTERA_UART_BAUDRATE
+        int "Default baudrate for Altera UART ports"
+        depends on SERIAL_ALTERA_UART
+        default 115200
+        help
+          This setting lets you define what the default baudrate is for the
+          Altera UART ports. The usual default varies from board to board,
+          and this setting is a way of catering for that.
+config SERIAL_ALTERA_UART_CONSOLE
+        bool "Altera UART console support"
+        depends on SERIAL_ALTERA_UART=y
+        select SERIAL_CORE_CONSOLE
+        help
+          Enable a Altera UART port to be the system console.
 endmenu
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 328f107346c4..208a85572c32 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -82,3 +82,5 @@ obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o
 obj-$(CONFIG_SERIAL_QE) += ucc_uart.o
 obj-$(CONFIG_SERIAL_TIMBERDALE) += timbuart.o
 obj-$(CONFIG_SERIAL_GRLIB_GAISLER_APBUART) += apbuart.o
+obj-$(CONFIG_SERIAL_ALTERA_JTAGUART) += altera_jtaguart.o
+obj-$(CONFIG_SERIAL_ALTERA_UART) += altera_uart.o
diff --git a/drivers/serial/altera_jtaguart.c b/drivers/serial/altera_jtaguart.c
new file mode 100644
index 000000000000..f9b49b5ff5e1
--- /dev/null
+++ b/drivers/serial/altera_jtaguart.c
@@ -0,0 +1,504 @@
+/*
+ * altera_jtaguart.c -- Altera JTAG UART driver
+ *
+ * Based on mcf.c -- Freescale ColdFire UART driver
+ *
+ * (C) Copyright 2003-2007, Greg Ungerer <gerg@snapgear.com>
+ * (C) Copyright 2008, Thomas Chou <thomas@wytron.com.tw>
+ * (C) Copyright 2010, Tobias Klauser <tklauser@distanz.ch>
+ *
+ * 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/kernel.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/console.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/altera_jtaguart.h>
+#define DRV_NAME "altera_jtaguart"
+/*
+ * Altera JTAG UART register definitions according to the Altera JTAG UART
+ * datasheet: http://www.altera.com/literature/hb/nios2/n2cpu_nii51009.pdf
+ */
+#define ALTERA_JTAGUART_SIZE                    8
+#define ALTERA_JTAGUART_DATA_REG                0
+#define ALTERA_JTAGUART_DATA_DATA_MSK           0x000000FF
+#define ALTERA_JTAGUART_DATA_RVALID_MSK         0x00008000
+#define ALTERA_JTAGUART_DATA_RAVAIL_MSK         0xFFFF0000
+#define ALTERA_JTAGUART_DATA_RAVAIL_OFF         16
+#define ALTERA_JTAGUART_CONTROL_REG             4
+#define ALTERA_JTAGUART_CONTROL_RE_MSK          0x00000001
+#define ALTERA_JTAGUART_CONTROL_WE_MSK          0x00000002
+#define ALTERA_JTAGUART_CONTROL_RI_MSK          0x00000100
+#define ALTERA_JTAGUART_CONTROL_RI_OFF          8
+#define ALTERA_JTAGUART_CONTROL_WI_MSK          0x00000200
+#define ALTERA_JTAGUART_CONTROL_AC_MSK          0x00000400
+#define ALTERA_JTAGUART_CONTROL_WSPACE_MSK      0xFFFF0000
+#define ALTERA_JTAGUART_CONTROL_WSPACE_OFF      16
+/*
+ * Local per-uart structure.
+ */
+struct altera_jtaguart {
+        struct uart_port port;
+        unsigned int sigs;      /* Local copy of line sigs */
+        unsigned long imr;      /* Local IMR mirror */
+};
+static unsigned int altera_jtaguart_tx_empty(struct uart_port *port)
+{
+        return (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) &
+                ALTERA_JTAGUART_CONTROL_WSPACE_MSK) ? TIOCSER_TEMT : 0;
+}
+static unsigned int altera_jtaguart_get_mctrl(struct uart_port *port)
+{
+        return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
+}
+static void altera_jtaguart_set_mctrl(struct uart_port *port, unsigned int sigs)
+{
+}
+static void altera_jtaguart_start_tx(struct uart_port *port)
+{
+        struct altera_jtaguart *pp =
+            container_of(port, struct altera_jtaguart, port);
+        pp->imr |= ALTERA_JTAGUART_CONTROL_WE_MSK;
+        writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+}
+static void altera_jtaguart_stop_tx(struct uart_port *port)
+{
+        struct altera_jtaguart *pp =
+            container_of(port, struct altera_jtaguart, port);
+        pp->imr &= ~ALTERA_JTAGUART_CONTROL_WE_MSK;
+        writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+}
+static void altera_jtaguart_stop_rx(struct uart_port *port)
+{
+        struct altera_jtaguart *pp =
+            container_of(port, struct altera_jtaguart, port);
+        pp->imr &= ~ALTERA_JTAGUART_CONTROL_RE_MSK;
+        writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+}
+static void altera_jtaguart_break_ctl(struct uart_port *port, int break_state)
+{
+}
+static void altera_jtaguart_enable_ms(struct uart_port *port)
+{
+}
+static void altera_jtaguart_set_termios(struct uart_port *port,
+                                        struct ktermios *termios,
+                                        struct ktermios *old)
+{
+        /* Just copy the old termios settings back */
+        if (old)
+                tty_termios_copy_hw(termios, old);
+}
+static void altera_jtaguart_rx_chars(struct altera_jtaguart *pp)
+{
+        struct uart_port *port = &pp->port;
+        unsigned char ch, flag;
+        unsigned long status;
+        while ((status = readl(port->membase + ALTERA_JTAGUART_DATA_REG)) &
+               ALTERA_JTAGUART_DATA_RVALID_MSK) {
+                ch = status & ALTERA_JTAGUART_DATA_DATA_MSK;
+                flag = TTY_NORMAL;
+                port->icount.rx++;
+                if (uart_handle_sysrq_char(port, ch))
+                        continue;
+                uart_insert_char(port, 0, 0, ch, flag);
+        }
+        tty_flip_buffer_push(port->state->port.tty);
+}
+static void altera_jtaguart_tx_chars(struct altera_jtaguart *pp)
+{
+        struct uart_port *port = &pp->port;
+        struct circ_buf *xmit = &port->state->xmit;
+        unsigned int pending, count;
+        if (port->x_char) {
+                /* Send special char - probably flow control */
+                writel(port->x_char, port->membase + ALTERA_JTAGUART_DATA_REG);
+                port->x_char = 0;
+                port->icount.tx++;
+                return;
+        }
+        pending = uart_circ_chars_pending(xmit);
+        if (pending > 0) {
+                count = (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) &
+                                ALTERA_JTAGUART_CONTROL_WSPACE_MSK) >>
+                        ALTERA_JTAGUART_CONTROL_WSPACE_OFF;
+                if (count > pending)
+                        count = pending;
+                if (count > 0) {
+                        pending -= count;
+                        while (count--) {
+                                writel(xmit->buf[xmit->tail],
+                                       port->membase + ALTERA_JTAGUART_DATA_REG);
+                                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                                port->icount.tx++;
+                        }
+                        if (pending < WAKEUP_CHARS)
+                                uart_write_wakeup(port);
+                }
+        }
+        if (pending == 0) {
+                pp->imr &= ~ALTERA_JTAGUART_CONTROL_WE_MSK;
+                writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+        }
+}
+static irqreturn_t altera_jtaguart_interrupt(int irq, void *data)
+{
+        struct uart_port *port = data;
+        struct altera_jtaguart *pp =
+            container_of(port, struct altera_jtaguart, port);
+        unsigned int isr;
+        isr = (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) >>
+               ALTERA_JTAGUART_CONTROL_RI_OFF) & pp->imr;
+        spin_lock(&port->lock);
+        if (isr & ALTERA_JTAGUART_CONTROL_RE_MSK)
+                altera_jtaguart_rx_chars(pp);
+        if (isr & ALTERA_JTAGUART_CONTROL_WE_MSK)
+                altera_jtaguart_tx_chars(pp);
+        spin_unlock(&port->lock);
+        return IRQ_RETVAL(isr);
+}
+static void altera_jtaguart_config_port(struct uart_port *port, int flags)
+{
+        port->type = PORT_ALTERA_JTAGUART;
+        /* Clear mask, so no surprise interrupts. */
+        writel(0, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+}
+static int altera_jtaguart_startup(struct uart_port *port)
+{
+        struct altera_jtaguart *pp =
+            container_of(port, struct altera_jtaguart, port);
+        unsigned long flags;
+        int ret;
+        ret = request_irq(port->irq, altera_jtaguart_interrupt, IRQF_DISABLED,
+                        DRV_NAME, port);
+        if (ret) {
+                pr_err(DRV_NAME ": unable to attach Altera JTAG UART %d "
+                       "interrupt vector=%d\n", port->line, port->irq);
+                return ret;
+        }
+        spin_lock_irqsave(&port->lock, flags);
+        /* Enable RX interrupts now */
+        pp->imr = ALTERA_JTAGUART_CONTROL_RE_MSK;
+        writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+        return 0;
+}
+static void altera_jtaguart_shutdown(struct uart_port *port)
+{
+        struct altera_jtaguart *pp =
+            container_of(port, struct altera_jtaguart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        /* Disable all interrupts now */
+        pp->imr = 0;
+        writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+        free_irq(port->irq, port);
+}
+static const char *altera_jtaguart_type(struct uart_port *port)
+{
+        return (port->type == PORT_ALTERA_JTAGUART) ? "Altera JTAG UART" : NULL;
+}
+static int altera_jtaguart_request_port(struct uart_port *port)
+{
+        /* UARTs always present */
+        return 0;
+}
+static void altera_jtaguart_release_port(struct uart_port *port)
+{
+        /* Nothing to release... */
+}
+static int altera_jtaguart_verify_port(struct uart_port *port,
+                                       struct serial_struct *ser)
+{
+        if (ser->type != PORT_UNKNOWN && ser->type != PORT_ALTERA_JTAGUART)
+                return -EINVAL;
+        return 0;
+}
+/*
+ *      Define the basic serial functions we support.
+ */
+static struct uart_ops altera_jtaguart_ops = {
+        .tx_empty       = altera_jtaguart_tx_empty,
+        .get_mctrl      = altera_jtaguart_get_mctrl,
+        .set_mctrl      = altera_jtaguart_set_mctrl,
+        .start_tx       = altera_jtaguart_start_tx,
+        .stop_tx        = altera_jtaguart_stop_tx,
+        .stop_rx        = altera_jtaguart_stop_rx,
+        .enable_ms      = altera_jtaguart_enable_ms,
+        .break_ctl      = altera_jtaguart_break_ctl,
+        .startup        = altera_jtaguart_startup,
+        .shutdown       = altera_jtaguart_shutdown,
+        .set_termios    = altera_jtaguart_set_termios,
+        .type           = altera_jtaguart_type,
+        .request_port   = altera_jtaguart_request_port,
+        .release_port   = altera_jtaguart_release_port,
+        .config_port    = altera_jtaguart_config_port,
+        .verify_port    = altera_jtaguart_verify_port,
+};
+#define ALTERA_JTAGUART_MAXPORTS 1
+static struct altera_jtaguart altera_jtaguart_ports[ALTERA_JTAGUART_MAXPORTS];
+#if defined(CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE)
+int __init early_altera_jtaguart_setup(struct altera_jtaguart_platform_uart
+                                       *platp)
+{
+        struct uart_port *port;
+        int i;
+        for (i = 0; i < ALTERA_JTAGUART_MAXPORTS && platp[i].mapbase; i++) {
+                port = &altera_jtaguart_ports[i].port;
+                port->line = i;
+                port->type = PORT_ALTERA_JTAGUART;
+                port->mapbase = platp[i].mapbase;
+                port->membase = ioremap(port->mapbase, ALTERA_JTAGUART_SIZE);
+                port->iotype = SERIAL_IO_MEM;
+                port->irq = platp[i].irq;
+                port->flags = ASYNC_BOOT_AUTOCONF;
+                port->ops = &altera_jtaguart_ops;
+        }
+        return 0;
+}
+#if defined(CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE_BYPASS)
+static void altera_jtaguart_console_putc(struct console *co, const char c)
+{
+        struct uart_port *port = &(altera_jtaguart_ports + co->index)->port;
+        unsigned long status;
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        while (((status = readl(port->membase + ALTERA_JTAGUART_CONTROL_REG)) &
+                ALTERA_JTAGUART_CONTROL_WSPACE_MSK) == 0) {
+                if ((status & ALTERA_JTAGUART_CONTROL_AC_MSK) == 0) {
+                        spin_unlock_irqrestore(&port->lock, flags);
+                        return; /* no connection activity */
+                }
+                spin_unlock_irqrestore(&port->lock, flags);
+                cpu_relax();
+                spin_lock_irqsave(&port->lock, flags);
+        }
+        writel(c, port->membase + ALTERA_JTAGUART_DATA_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+#else
+static void altera_jtaguart_console_putc(struct console *co, const char c)
+{
+        struct uart_port *port = &(altera_jtaguart_ports + co->index)->port;
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        while ((readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) &
+                ALTERA_JTAGUART_CONTROL_WSPACE_MSK) == 0) {
+                spin_unlock_irqrestore(&port->lock, flags);
+                cpu_relax();
+                spin_lock_irqsave(&port->lock, flags);
+        }
+        writel(c, port->membase + ALTERA_JTAGUART_DATA_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+#endif
+static void altera_jtaguart_console_write(struct console *co, const char *s,
+                                          unsigned int count)
+{
+        for (; count; count--, s++) {
+                altera_jtaguart_console_putc(co, *s);
+                if (*s == '\n')
+                        altera_jtaguart_console_putc(co, '\r');
+        }
+}
+static int __init altera_jtaguart_console_setup(struct console *co,
+                                                char *options)
+{
+        struct uart_port *port;
+        if (co->index < 0 || co->index >= ALTERA_JTAGUART_MAXPORTS)
+                return -EINVAL;
+        port = &altera_jtaguart_ports[co->index].port;
+        if (port->membase == 0)
+                return -ENODEV;
+        return 0;
+}
+static struct uart_driver altera_jtaguart_driver;
+static struct console altera_jtaguart_console = {
+        .name   = "ttyJ",
+        .write  = altera_jtaguart_console_write,
+        .device = uart_console_device,
+        .setup  = altera_jtaguart_console_setup,
+        .flags  = CON_PRINTBUFFER,
+        .index  = -1,
+        .data   = &altera_jtaguart_driver,
+};
+static int __init altera_jtaguart_console_init(void)
+{
+        register_console(&altera_jtaguart_console);
+        return 0;
+}
+console_initcall(altera_jtaguart_console_init);
+#define ALTERA_JTAGUART_CONSOLE (&altera_jtaguart_console)
+#else
+#define ALTERA_JTAGUART_CONSOLE NULL
+#endif /* CONFIG_ALTERA_JTAGUART_CONSOLE */
+static struct uart_driver altera_jtaguart_driver = {
+        .owner          = THIS_MODULE,
+        .driver_name    = "altera_jtaguart",
+        .dev_name       = "ttyJ",
+        .major          = ALTERA_JTAGUART_MAJOR,
+        .minor          = ALTERA_JTAGUART_MINOR,
+        .nr             = ALTERA_JTAGUART_MAXPORTS,
+        .cons           = ALTERA_JTAGUART_CONSOLE,
+};
+static int __devinit altera_jtaguart_probe(struct platform_device *pdev)
+{
+        struct altera_jtaguart_platform_uart *platp = pdev->dev.platform_data;
+        struct uart_port *port;
+        int i;
+        for (i = 0; i < ALTERA_JTAGUART_MAXPORTS && platp[i].mapbase; i++) {
+                port = &altera_jtaguart_ports[i].port;
+                port->line = i;
+                port->type = PORT_ALTERA_JTAGUART;
+                port->mapbase = platp[i].mapbase;
+                port->membase = ioremap(port->mapbase, ALTERA_JTAGUART_SIZE);
+                port->iotype = SERIAL_IO_MEM;
+                port->irq = platp[i].irq;
+                port->ops = &altera_jtaguart_ops;
+                port->flags = ASYNC_BOOT_AUTOCONF;
+                uart_add_one_port(&altera_jtaguart_driver, port);
+        }
+        return 0;
+}
+static int __devexit altera_jtaguart_remove(struct platform_device *pdev)
+{
+        struct uart_port *port;
+        int i;
+        for (i = 0; i < ALTERA_JTAGUART_MAXPORTS; i++) {
+                port = &altera_jtaguart_ports[i].port;
+                if (port)
+                        uart_remove_one_port(&altera_jtaguart_driver, port);
+        }
+        return 0;
+}
+static struct platform_driver altera_jtaguart_platform_driver = {
+        .probe  = altera_jtaguart_probe,
+        .remove = __devexit_p(altera_jtaguart_remove),
+        .driver = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+static int __init altera_jtaguart_init(void)
+{
+        int rc;
+        rc = uart_register_driver(&altera_jtaguart_driver);
+        if (rc)
+                return rc;
+        rc = platform_driver_register(&altera_jtaguart_platform_driver);
+        if (rc) {
+                uart_unregister_driver(&altera_jtaguart_driver);
+                return rc;
+        }
+        return 0;
+}
+static void __exit altera_jtaguart_exit(void)
+{
+        platform_driver_unregister(&altera_jtaguart_platform_driver);
+        uart_unregister_driver(&altera_jtaguart_driver);
+}
+module_init(altera_jtaguart_init);
+module_exit(altera_jtaguart_exit);
+MODULE_DESCRIPTION("Altera JTAG UART driver");
+MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/serial/altera_uart.c b/drivers/serial/altera_uart.c
new file mode 100644
index 000000000000..bcee156d2f2e
--- /dev/null
+++ b/drivers/serial/altera_uart.c
@@ -0,0 +1,570 @@
+/*
+ * altera_uart.c -- Altera UART driver
+ *
+ * Based on mcf.c -- Freescale ColdFire UART driver
+ *
+ * (C) Copyright 2003-2007, Greg Ungerer <gerg@snapgear.com>
+ * (C) Copyright 2008, Thomas Chou <thomas@wytron.com.tw>
+ * (C) Copyright 2010, Tobias Klauser <tklauser@distanz.ch>
+ *
+ * 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/kernel.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/console.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/altera_uart.h>
+#define DRV_NAME "altera_uart"
+/*
+ * Altera UART register definitions according to the Nios UART datasheet:
+ * http://www.altera.com/literature/ds/ds_nios_uart.pdf
+ */
+#define ALTERA_UART_SIZE                32
+#define ALTERA_UART_RXDATA_REG          0
+#define ALTERA_UART_TXDATA_REG          4
+#define ALTERA_UART_STATUS_REG          8
+#define ALTERA_UART_CONTROL_REG         12
+#define ALTERA_UART_DIVISOR_REG         16
+#define ALTERA_UART_EOP_REG             20
+#define ALTERA_UART_STATUS_PE_MSK       0x0001  /* parity error */
+#define ALTERA_UART_STATUS_FE_MSK       0x0002  /* framing error */
+#define ALTERA_UART_STATUS_BRK_MSK      0x0004  /* break */
+#define ALTERA_UART_STATUS_ROE_MSK      0x0008  /* RX overrun error */
+#define ALTERA_UART_STATUS_TOE_MSK      0x0010  /* TX overrun error */
+#define ALTERA_UART_STATUS_TMT_MSK      0x0020  /* TX shift register state */
+#define ALTERA_UART_STATUS_TRDY_MSK     0x0040  /* TX ready */
+#define ALTERA_UART_STATUS_RRDY_MSK     0x0080  /* RX ready */
+#define ALTERA_UART_STATUS_E_MSK        0x0100  /* exception condition */
+#define ALTERA_UART_STATUS_DCTS_MSK     0x0400  /* CTS logic-level change */
+#define ALTERA_UART_STATUS_CTS_MSK      0x0800  /* CTS logic state */
+#define ALTERA_UART_STATUS_EOP_MSK      0x1000  /* EOP written/read */
+                                                /* Enable interrupt on... */
+#define ALTERA_UART_CONTROL_PE_MSK      0x0001  /* ...parity error */
+#define ALTERA_UART_CONTROL_FE_MSK      0x0002  /* ...framing error */
+#define ALTERA_UART_CONTROL_BRK_MSK     0x0004  /* ...break */
+#define ALTERA_UART_CONTROL_ROE_MSK     0x0008  /* ...RX overrun */
+#define ALTERA_UART_CONTROL_TOE_MSK     0x0010  /* ...TX overrun */
+#define ALTERA_UART_CONTROL_TMT_MSK     0x0020  /* ...TX shift register empty */
+#define ALTERA_UART_CONTROL_TRDY_MSK    0x0040  /* ...TX ready */
+#define ALTERA_UART_CONTROL_RRDY_MSK    0x0080  /* ...RX ready */
+#define ALTERA_UART_CONTROL_E_MSK       0x0100  /* ...exception*/
+#define ALTERA_UART_CONTROL_TRBK_MSK    0x0200  /* TX break */
+#define ALTERA_UART_CONTROL_DCTS_MSK    0x0400  /* Interrupt on CTS change */
+#define ALTERA_UART_CONTROL_RTS_MSK     0x0800  /* RTS signal */
+#define ALTERA_UART_CONTROL_EOP_MSK     0x1000  /* Interrupt on EOP */
+/*
+ * Local per-uart structure.
+ */
+struct altera_uart {
+        struct uart_port port;
+        unsigned int sigs;      /* Local copy of line sigs */
+        unsigned short imr;     /* Local IMR mirror */
+};
+static unsigned int altera_uart_tx_empty(struct uart_port *port)
+{
+        return (readl(port->membase + ALTERA_UART_STATUS_REG) &
+                ALTERA_UART_STATUS_TMT_MSK) ? TIOCSER_TEMT : 0;
+}
+static unsigned int altera_uart_get_mctrl(struct uart_port *port)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        unsigned int sigs;
+        spin_lock_irqsave(&port->lock, flags);
+        sigs =
+            (readl(port->membase + ALTERA_UART_STATUS_REG) &
+             ALTERA_UART_STATUS_CTS_MSK) ? TIOCM_CTS : 0;
+        sigs |= (pp->sigs & TIOCM_RTS);
+        spin_unlock_irqrestore(&port->lock, flags);
+        return sigs;
+}
+static void altera_uart_set_mctrl(struct uart_port *port, unsigned int sigs)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        pp->sigs = sigs;
+        if (sigs & TIOCM_RTS)
+                pp->imr |= ALTERA_UART_CONTROL_RTS_MSK;
+        else
+                pp->imr &= ~ALTERA_UART_CONTROL_RTS_MSK;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+static void altera_uart_start_tx(struct uart_port *port)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        pp->imr |= ALTERA_UART_CONTROL_TRDY_MSK;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+static void altera_uart_stop_tx(struct uart_port *port)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        pp->imr &= ~ALTERA_UART_CONTROL_TRDY_MSK;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+static void altera_uart_stop_rx(struct uart_port *port)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        pp->imr &= ~ALTERA_UART_CONTROL_RRDY_MSK;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+static void altera_uart_break_ctl(struct uart_port *port, int break_state)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        if (break_state == -1)
+                pp->imr |= ALTERA_UART_CONTROL_TRBK_MSK;
+        else
+                pp->imr &= ~ALTERA_UART_CONTROL_TRBK_MSK;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+static void altera_uart_enable_ms(struct uart_port *port)
+{
+}
+static void altera_uart_set_termios(struct uart_port *port,
+                                    struct ktermios *termios,
+                                    struct ktermios *old)
+{
+        unsigned long flags;
+        unsigned int baud, baudclk;
+        baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
+        baudclk = port->uartclk / baud;
+        if (old)
+                tty_termios_copy_hw(termios, old);
+        tty_termios_encode_baud_rate(termios, baud, baud);
+        spin_lock_irqsave(&port->lock, flags);
+        writel(baudclk, port->membase + ALTERA_UART_DIVISOR_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+static void altera_uart_rx_chars(struct altera_uart *pp)
+{
+        struct uart_port *port = &pp->port;
+        unsigned char ch, flag;
+        unsigned short status;
+        while ((status = readl(port->membase + ALTERA_UART_STATUS_REG)) &
+               ALTERA_UART_STATUS_RRDY_MSK) {
+                ch = readl(port->membase + ALTERA_UART_RXDATA_REG);
+                flag = TTY_NORMAL;
+                port->icount.rx++;
+                if (status & ALTERA_UART_STATUS_E_MSK) {
+                        writel(status, port->membase + ALTERA_UART_STATUS_REG);
+                        if (status & ALTERA_UART_STATUS_BRK_MSK) {
+                                port->icount.brk++;
+                                if (uart_handle_break(port))
+                                        continue;
+                        } else if (status & ALTERA_UART_STATUS_PE_MSK) {
+                                port->icount.parity++;
+                        } else if (status & ALTERA_UART_STATUS_ROE_MSK) {
+                                port->icount.overrun++;
+                        } else if (status & ALTERA_UART_STATUS_FE_MSK) {
+                                port->icount.frame++;
+                        }
+                        status &= port->read_status_mask;
+                        if (status & ALTERA_UART_STATUS_BRK_MSK)
+                                flag = TTY_BREAK;
+                        else if (status & ALTERA_UART_STATUS_PE_MSK)
+                                flag = TTY_PARITY;
+                        else if (status & ALTERA_UART_STATUS_FE_MSK)
+                                flag = TTY_FRAME;
+                }
+                if (uart_handle_sysrq_char(port, ch))
+                        continue;
+                uart_insert_char(port, status, ALTERA_UART_STATUS_ROE_MSK, ch,
+                                 flag);
+        }
+        tty_flip_buffer_push(port->state->port.tty);
+}
+static void altera_uart_tx_chars(struct altera_uart *pp)
+{
+        struct uart_port *port = &pp->port;
+        struct circ_buf *xmit = &port->state->xmit;
+        if (port->x_char) {
+                /* Send special char - probably flow control */
+                writel(port->x_char, port->membase + ALTERA_UART_TXDATA_REG);
+                port->x_char = 0;
+                port->icount.tx++;
+                return;
+        }
+        while (readl(port->membase + ALTERA_UART_STATUS_REG) &
+               ALTERA_UART_STATUS_TRDY_MSK) {
+                if (xmit->head == xmit->tail)
+                        break;
+                writel(xmit->buf[xmit->tail],
+                       port->membase + ALTERA_UART_TXDATA_REG);
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                port->icount.tx++;
+        }
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(port);
+        if (xmit->head == xmit->tail) {
+                pp->imr &= ~ALTERA_UART_CONTROL_TRDY_MSK;
+                writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        }
+}
+static irqreturn_t altera_uart_interrupt(int irq, void *data)
+{
+        struct uart_port *port = data;
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned int isr;
+        isr = readl(port->membase + ALTERA_UART_STATUS_REG) & pp->imr;
+        if (isr & ALTERA_UART_STATUS_RRDY_MSK)
+                altera_uart_rx_chars(pp);
+        if (isr & ALTERA_UART_STATUS_TRDY_MSK)
+                altera_uart_tx_chars(pp);
+        return IRQ_RETVAL(isr);
+}
+static void altera_uart_config_port(struct uart_port *port, int flags)
+{
+        port->type = PORT_ALTERA_UART;
+        /* Clear mask, so no surprise interrupts. */
+        writel(0, port->membase + ALTERA_UART_CONTROL_REG);
+        /* Clear status register */
+        writel(0, port->membase + ALTERA_UART_STATUS_REG);
+}
+static int altera_uart_startup(struct uart_port *port)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        int ret;
+        ret = request_irq(port->irq, altera_uart_interrupt, IRQF_DISABLED,
+                        DRV_NAME, port);
+        if (ret) {
+                pr_err(DRV_NAME ": unable to attach Altera UART %d "
+                       "interrupt vector=%d\n", port->line, port->irq);
+                return ret;
+        }
+        spin_lock_irqsave(&port->lock, flags);
+        /* Enable RX interrupts now */
+        pp->imr = ALTERA_UART_CONTROL_RRDY_MSK;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+        return 0;
+}
+static void altera_uart_shutdown(struct uart_port *port)
+{
+        struct altera_uart *pp = container_of(port, struct altera_uart, port);
+        unsigned long flags;
+        spin_lock_irqsave(&port->lock, flags);
+        /* Disable all interrupts now */
+        pp->imr = 0;
+        writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
+        spin_unlock_irqrestore(&port->lock, flags);
+        free_irq(port->irq, port);
+}
+static const char *altera_uart_type(struct uart_port *port)
+{
+        return (port->type == PORT_ALTERA_UART) ? "Altera UART" : NULL;
+}
+static int altera_uart_request_port(struct uart_port *port)
+{
+        /* UARTs always present */
+        return 0;
+}
+static void altera_uart_release_port(struct uart_port *port)
+{
+        /* Nothing to release... */
+}
+static int altera_uart_verify_port(struct uart_port *port,
+                                   struct serial_struct *ser)
+{
+        if ((ser->type != PORT_UNKNOWN) && (ser->type != PORT_ALTERA_UART))
+                return -EINVAL;
+        return 0;
+}
+/*
+ *      Define the basic serial functions we support.
+ */
+static struct uart_ops altera_uart_ops = {
+        .tx_empty       = altera_uart_tx_empty,
+        .get_mctrl      = altera_uart_get_mctrl,
+        .set_mctrl      = altera_uart_set_mctrl,
+        .start_tx       = altera_uart_start_tx,
+        .stop_tx        = altera_uart_stop_tx,
+        .stop_rx        = altera_uart_stop_rx,
+        .enable_ms      = altera_uart_enable_ms,
+        .break_ctl      = altera_uart_break_ctl,
+        .startup        = altera_uart_startup,
+        .shutdown       = altera_uart_shutdown,
+        .set_termios    = altera_uart_set_termios,
+        .type           = altera_uart_type,
+        .request_port   = altera_uart_request_port,
+        .release_port   = altera_uart_release_port,
+        .config_port    = altera_uart_config_port,
+        .verify_port    = altera_uart_verify_port,
+};
+static struct altera_uart altera_uart_ports[CONFIG_SERIAL_ALTERA_UART_MAXPORTS];
+#if defined(CONFIG_SERIAL_ALTERA_UART_CONSOLE)
+int __init early_altera_uart_setup(struct altera_uart_platform_uart *platp)
+{
+        struct uart_port *port;
+        int i;
+        for (i = 0; i < CONFIG_SERIAL_ALTERA_UART_MAXPORTS && platp[i].mapbase; i++) {
+                port = &altera_uart_ports[i].port;
+                port->line = i;
+                port->type = PORT_ALTERA_UART;
+                port->mapbase = platp[i].mapbase;
+                port->membase = ioremap(port->mapbase, ALTERA_UART_SIZE);
+                port->iotype = SERIAL_IO_MEM;
+                port->irq = platp[i].irq;
+                port->uartclk = platp[i].uartclk;
+                port->flags = ASYNC_BOOT_AUTOCONF;
+                port->ops = &altera_uart_ops;
+        }
+        return 0;
+}
+static void altera_uart_console_putc(struct console *co, const char c)
+{
+        struct uart_port *port = &(altera_uart_ports + co->index)->port;
+        int i;
+        for (i = 0; i < 0x10000; i++) {
+                if (readl(port->membase + ALTERA_UART_STATUS_REG) &
+                    ALTERA_UART_STATUS_TRDY_MSK)
+                        break;
+        }
+        writel(c, port->membase + ALTERA_UART_TXDATA_REG);
+        for (i = 0; i < 0x10000; i++) {
+                if (readl(port->membase + ALTERA_UART_STATUS_REG) &
+                    ALTERA_UART_STATUS_TRDY_MSK)
+                        break;
+        }
+}
+static void altera_uart_console_write(struct console *co, const char *s,
+                                      unsigned int count)
+{
+        for (; count; count--, s++) {
+                altera_uart_console_putc(co, *s);
+                if (*s == '\n')
+                        altera_uart_console_putc(co, '\r');
+        }
+}
+static int __init altera_uart_console_setup(struct console *co, char *options)
+{
+        struct uart_port *port;
+        int baud = CONFIG_SERIAL_ALTERA_UART_BAUDRATE;
+        int bits = 8;
+        int parity = 'n';
+        int flow = 'n';
+        if (co->index < 0 || co->index >= CONFIG_SERIAL_ALTERA_UART_MAXPORTS)
+                return -EINVAL;
+        port = &altera_uart_ports[co->index].port;
+        if (port->membase == 0)
+                return -ENODEV;
+        if (options)
+                uart_parse_options(options, &baud, &parity, &bits, &flow);
+        return uart_set_options(port, co, baud, parity, bits, flow);
+}
+static struct uart_driver altera_uart_driver;
+static struct console altera_uart_console = {
+        .name   = "ttyS",
+        .write  = altera_uart_console_write,
+        .device = uart_console_device,
+        .setup  = altera_uart_console_setup,
+        .flags  = CON_PRINTBUFFER,
+        .index  = -1,
+        .data   = &altera_uart_driver,
+};
+static int __init altera_uart_console_init(void)
+{
+        register_console(&altera_uart_console);
+        return 0;
+}
+console_initcall(altera_uart_console_init);
+#define ALTERA_UART_CONSOLE     (&altera_uart_console)
+#else
+#define ALTERA_UART_CONSOLE     NULL
+#endif /* CONFIG_ALTERA_UART_CONSOLE */
+/*
+ *      Define the altera_uart UART driver structure.
+ */
+static struct uart_driver altera_uart_driver = {
+        .owner          = THIS_MODULE,
+        .driver_name    = DRV_NAME,
+        .dev_name       = "ttyS",
+        .major          = TTY_MAJOR,
+        .minor          = 64,
+        .nr             = CONFIG_SERIAL_ALTERA_UART_MAXPORTS,
+        .cons           = ALTERA_UART_CONSOLE,
+};
+static int __devinit altera_uart_probe(struct platform_device *pdev)
+{
+        struct altera_uart_platform_uart *platp = pdev->dev.platform_data;
+        struct uart_port *port;
+        int i;
+        for (i = 0; i < CONFIG_SERIAL_ALTERA_UART_MAXPORTS && platp[i].mapbase; i++) {
+                port = &altera_uart_ports[i].port;
+                port->line = i;
+                port->type = PORT_ALTERA_UART;
+                port->mapbase = platp[i].mapbase;
+                port->membase = ioremap(port->mapbase, ALTERA_UART_SIZE);
+                port->iotype = SERIAL_IO_MEM;
+                port->irq = platp[i].irq;
+                port->uartclk = platp[i].uartclk;
+                port->ops = &altera_uart_ops;
+                port->flags = ASYNC_BOOT_AUTOCONF;
+                uart_add_one_port(&altera_uart_driver, port);
+        }
+        return 0;
+}
+static int altera_uart_remove(struct platform_device *pdev)
+{
+        struct uart_port *port;
+        int i;
+        for (i = 0; i < CONFIG_SERIAL_ALTERA_UART_MAXPORTS; i++) {
+                port = &altera_uart_ports[i].port;
+                if (port)
+                        uart_remove_one_port(&altera_uart_driver, port);
+        }
+        return 0;
+}
+static struct platform_driver altera_uart_platform_driver = {
+        .probe  = altera_uart_probe,
+        .remove = __devexit_p(altera_uart_remove),
+        .driver = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+                .pm     = NULL,
+        },
+};
+static int __init altera_uart_init(void)
+{
+        int rc;
+        rc = uart_register_driver(&altera_uart_driver);
+        if (rc)
+                return rc;
+        rc = platform_driver_register(&altera_uart_platform_driver);
+        if (rc) {
+                uart_unregister_driver(&altera_uart_driver);
+                return rc;
+        }
+        return 0;
+}
+static void __exit altera_uart_exit(void)
+{
+        platform_driver_unregister(&altera_uart_platform_driver);
+        uart_unregister_driver(&altera_uart_driver);
+}
+module_init(altera_uart_init);
+module_exit(altera_uart_exit);
+MODULE_DESCRIPTION("Altera UART driver");
+MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index c88f8ad3ff82..e57fb3d228e2 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -34,32 +34,12 @@
 #include <linux/tty_flip.h>
 #include <linux/serial_core.h>
+#include <asm/bfin_sport.h>
 #include <asm/delay.h>
 #include <asm/portmux.h>
 #include "bfin_sport_uart.h"
-#ifdef CONFIG_SERIAL_BFIN_SPORT0_UART
-unsigned short bfin_uart_pin_req_sport0[] =
-        {P_SPORT0_TFS, P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS, \
-         P_SPORT0_DRPRI, P_SPORT0_RSCLK, P_SPORT0_DRSEC, P_SPORT0_DTSEC, 0};
-#endif
-#ifdef CONFIG_SERIAL_BFIN_SPORT1_UART
-unsigned short bfin_uart_pin_req_sport1[] =
-        {P_SPORT1_TFS, P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, \
-        P_SPORT1_DRPRI, P_SPORT1_RSCLK, P_SPORT1_DRSEC, P_SPORT1_DTSEC, 0};
-#endif
-#ifdef CONFIG_SERIAL_BFIN_SPORT2_UART
-unsigned short bfin_uart_pin_req_sport2[] =
-        {P_SPORT2_TFS, P_SPORT2_DTPRI, P_SPORT2_TSCLK, P_SPORT2_RFS, \
-        P_SPORT2_DRPRI, P_SPORT2_RSCLK, P_SPORT2_DRSEC, P_SPORT2_DTSEC, 0};
-#endif
-#ifdef CONFIG_SERIAL_BFIN_SPORT3_UART
-unsigned short bfin_uart_pin_req_sport3[] =
-        {P_SPORT3_TFS, P_SPORT3_DTPRI, P_SPORT3_TSCLK, P_SPORT3_RFS, \
-        P_SPORT3_DRPRI, P_SPORT3_RSCLK, P_SPORT3_DRSEC, P_SPORT3_DTSEC, 0};
-#endif
 struct sport_uart_port {
        struct uart_port        port;
        int                     err_irq;
@@ -69,9 +49,13 @@ struct sport_uart_port {
        unsigned short          txmask2;
        unsigned char           stopb;
 /*      unsigned char           parib; */
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+        int cts_pin;
+        int rts_pin;
+#endif
 };
-static void sport_uart_tx_chars(struct sport_uart_port *up);
+static int sport_uart_tx_chars(struct sport_uart_port *up);
 static void sport_stop_tx(struct uart_port *port);
 static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value)
@@ -219,6 +203,59 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+static unsigned int sport_get_mctrl(struct uart_port *port)
+{
+        struct sport_uart_port *up = (struct sport_uart_port *)port;
+        if (up->cts_pin < 0)
+                return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
+        /* CTS PIN is negative assertive. */
+        if (SPORT_UART_GET_CTS(up))
+                return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
+        else
+                return TIOCM_DSR | TIOCM_CAR;
+}
+static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+        struct sport_uart_port *up = (struct sport_uart_port *)port;
+        if (up->rts_pin < 0)
+                return;
+        /* RTS PIN is negative assertive. */
+        if (mctrl & TIOCM_RTS)
+                SPORT_UART_ENABLE_RTS(up);
+        else
+                SPORT_UART_DISABLE_RTS(up);
+}
+/*
+ * Handle any change of modem status signal.
+ */
+static irqreturn_t sport_mctrl_cts_int(int irq, void *dev_id)
+{
+        struct sport_uart_port *up = (struct sport_uart_port *)dev_id;
+        unsigned int status;
+        status = sport_get_mctrl(&up->port);
+        uart_handle_cts_change(&up->port, status & TIOCM_CTS);
+        return IRQ_HANDLED;
+}
+#else
+static unsigned int sport_get_mctrl(struct uart_port *port)
+{
+        pr_debug("%s enter\n", __func__);
+        return TIOCM_CTS | TIOCM_CD | TIOCM_DSR;
+}
+static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+        pr_debug("%s enter\n", __func__);
+}
+#endif
 /* Reqeust IRQ, Setup clock */
 static int sport_startup(struct uart_port *port)
 {
@@ -247,6 +284,21 @@ static int sport_startup(struct uart_port *port)
                goto fail2;
        }
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+        if (up->cts_pin >= 0) {
+                if (request_irq(gpio_to_irq(up->cts_pin),
+                        sport_mctrl_cts_int,
+                        IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
+                        IRQF_DISABLED, "BFIN_SPORT_UART_CTS", up)) {
+                        up->cts_pin = -1;
+                        dev_info(port->dev, "Unable to attach BlackFin UART \
+                                over SPORT CTS interrupt. So, disable it.\n");
+                }
+        }
+        if (up->rts_pin >= 0)
+                gpio_direction_output(up->rts_pin, 0);
+#endif
        return 0;
 fail2:
        free_irq(up->port.irq+1, up);
@@ -256,23 +308,35 @@ static int sport_startup(struct uart_port *port)
        return ret;
 }
-static void sport_uart_tx_chars(struct sport_uart_port *up)
+/*
+ * sport_uart_tx_chars
+ *
+ * ret 1 means need to enable sport.
+ * ret 0 means do nothing.
+ */
+static int sport_uart_tx_chars(struct sport_uart_port *up)
 {
        struct circ_buf *xmit = &up->port.state->xmit;
        if (SPORT_GET_STAT(up) & TXF)
-                return;
+                return 0;
        if (up->port.x_char) {
                tx_one_byte(up, up->port.x_char);
                up->port.icount.tx++;
                up->port.x_char = 0;
-                return;
+                return 1;
        }
        if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
-                sport_stop_tx(&up->port);
+                /* The waiting loop to stop SPORT TX from TX interrupt is
-                return;
+                 * too long. This may block SPORT RX interrupts and cause
+                 * RX FIFO overflow. So, do stop sport TX only after the last
+                 * char in TX FIFO is moved into the shift register.
+                 */
+                if (SPORT_GET_STAT(up) & TXHRE)
+                        sport_stop_tx(&up->port);
+                return 0;
        }
        while(!(SPORT_GET_STAT(up) & TXF) && !uart_circ_empty(xmit)) {
@@ -283,6 +347,8 @@ static void sport_uart_tx_chars(struct sport_uart_port *up)
        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
                uart_write_wakeup(&up->port);
+        return 1;
 }
 static unsigned int sport_tx_empty(struct uart_port *port)
@@ -298,23 +364,15 @@ static unsigned int sport_tx_empty(struct uart_port *port)
                return 0;
 }
-static unsigned int sport_get_mctrl(struct uart_port *port)
-{
-        pr_debug("%s enter\n", __func__);
-        return (TIOCM_CTS | TIOCM_CD | TIOCM_DSR);
-}
-static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
-{
-        pr_debug("%s enter\n", __func__);
-}
 static void sport_stop_tx(struct uart_port *port)
 {
        struct sport_uart_port *up = (struct sport_uart_port *)port;
        pr_debug("%s enter\n", __func__);
+        if (!(SPORT_GET_TCR1(up) & TSPEN))
+                return;
        /* Although the hold register is empty, last byte is still in shift
         * register and not sent out yet. So, put a dummy data into TX FIFO.
         * Then, sport tx stops when last byte is shift out and the dummy
@@ -337,11 +395,12 @@ static void sport_start_tx(struct uart_port *port)
        pr_debug("%s enter\n", __func__);
        /* Write data into SPORT FIFO before enable SPROT to transmit */
-        sport_uart_tx_chars(up);
+        if (sport_uart_tx_chars(up)) {
+                /* Enable transmit, then an interrupt will generated */
+                SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
+                SSYNC();
+        }
-        /* Enable transmit, then an interrupt will generated */
-        SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
-        SSYNC();
        pr_debug("%s exit\n", __func__);
 }
@@ -379,6 +438,10 @@ static void sport_shutdown(struct uart_port *port)
        free_irq(up->port.irq, up);
        free_irq(up->port.irq+1, up);
        free_irq(up->err_irq, up);
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+        if (up->cts_pin >= 0)
+                free_irq(gpio_to_irq(up->cts_pin), up);
+#endif
 }
 static const char *sport_type(struct uart_port *port)
@@ -448,27 +511,14 @@ static void sport_set_termios(struct uart_port *port,
                /* up->parib = 1; */
        }
-        port->read_status_mask = OE;
+        spin_lock_irqsave(&up->port.lock, flags);
-        if (termios->c_iflag & INPCK)
-                port->read_status_mask |= (FE | PE);
+        port->read_status_mask = 0;
-        if (termios->c_iflag & (BRKINT | PARMRK))
-                port->read_status_mask |= BI;
        /*
         * Characters to ignore
         */
        port->ignore_status_mask = 0;
-        if (termios->c_iflag & IGNPAR)
-                port->ignore_status_mask |= FE | PE;
-        if (termios->c_iflag & IGNBRK) {
-                port->ignore_status_mask |= BI;
-                /*
-                 * If we're ignoring parity and break indicators,
-                 * ignore overruns too (for real raw support).
-                 */
-                if (termios->c_iflag & IGNPAR)
-                        port->ignore_status_mask |= OE;
-        }
        /* RX extract mask */
        up->rxmask = 0x01 | (((up->csize + up->stopb) * 2 - 1) << 0x8);
@@ -488,8 +538,6 @@ static void sport_set_termios(struct uart_port *port,
        /* uart baud rate */
        port->uartclk = uart_get_baud_rate(port, termios, old, 0, get_sclk()/16);
-        spin_lock_irqsave(&up->port.lock, flags);
        /* Disable UART */
        SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
        SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN);
@@ -542,6 +590,8 @@ struct uart_ops sport_uart_ops = {
 static struct sport_uart_port *bfin_sport_uart_ports[BFIN_SPORT_UART_MAX_PORTS];
 #ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
+#define CLASS_BFIN_SPORT_CONSOLE        "bfin-sport-console"
 static int __init
 sport_uart_console_setup(struct console *co, char *options)
 {
@@ -549,7 +599,11 @@ sport_uart_console_setup(struct console *co, char *options)
        int baud = 57600;
        int bits = 8;
        int parity = 'n';
+# ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+        int flow = 'r';
+# else
        int flow = 'n';
+# endif
        /* Check whether an invalid uart number has been specified */
        if (co->index < 0 || co->index >= BFIN_SPORT_UART_MAX_PORTS)
@@ -690,11 +744,11 @@ static int __devinit sport_uart_probe(struct platform_device *pdev)
        if (bfin_sport_uart_ports[pdev->id] == NULL) {
                bfin_sport_uart_ports[pdev->id] =
-                        kmalloc(sizeof(struct sport_uart_port), GFP_KERNEL);
+                        kzalloc(sizeof(struct sport_uart_port), GFP_KERNEL);
                sport = bfin_sport_uart_ports[pdev->id];
                if (!sport) {
                        dev_err(&pdev->dev,
-                                "Fail to kmalloc sport_uart_port\n");
+                                "Fail to malloc sport_uart_port\n");
                        return -ENOMEM;
                }
@@ -720,13 +774,13 @@ static int __devinit sport_uart_probe(struct platform_device *pdev)
                        goto out_error_free_peripherals;
                }
-                sport->port.membase = ioremap(res->start,
+                sport->port.membase = ioremap(res->start, resource_size(res));
-                        res->end - res->start);
                if (!sport->port.membase) {
                        dev_err(&pdev->dev, "Cannot map sport IO\n");
                        ret = -ENXIO;
                        goto out_error_free_peripherals;
                }
+                sport->port.mapbase = res->start;
                sport->port.irq = platform_get_irq(pdev, 0);
                if (sport->port.irq < 0) {
@@ -741,6 +795,22 @@ static int __devinit sport_uart_probe(struct platform_device *pdev)
                        ret = -ENOENT;
                        goto out_error_unmap;
                }
+#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+                res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+                if (res == NULL)
+                        sport->cts_pin = -1;
+                else
+                        sport->cts_pin = res->start;
+                res = platform_get_resource(pdev, IORESOURCE_IO, 1);
+                if (res == NULL)
+                        sport->rts_pin = -1;
+                else
+                        sport->rts_pin = res->start;
+                if (sport->rts_pin >= 0)
+                        gpio_request(sport->rts_pin, DRV_NAME);
+#endif
        }
 #ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
@@ -779,6 +849,10 @@ static int __devexit sport_uart_remove(struct platform_device *pdev)
        if (sport) {
                uart_remove_one_port(&sport_uart_reg, &sport->port);
+#ifdef CONFIG_SERIAL_BFIN_CTSRTS
+                if (sport->rts_pin >= 0)
+                        gpio_free(sport->rts_pin);
+#endif
                iounmap(sport->port.membase);
                peripheral_free_list(
                        (unsigned short *)pdev->dev.platform_data);
@@ -802,7 +876,7 @@ static struct platform_driver sport_uart_driver = {
 #ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
 static __initdata struct early_platform_driver early_sport_uart_driver = {
-        .class_str = DRV_NAME,
+        .class_str = CLASS_BFIN_SPORT_CONSOLE,
        .pdrv = &sport_uart_driver,
        .requested_id = EARLY_PLATFORM_ID_UNSET,
 };
@@ -811,7 +885,8 @@ static int __init sport_uart_rs_console_init(void)
 {
        early_platform_driver_register(&early_sport_uart_driver, DRV_NAME);
-        early_platform_driver_probe(DRV_NAME, BFIN_SPORT_UART_MAX_PORTS, 0);
+        early_platform_driver_probe(CLASS_BFIN_SPORT_CONSOLE,
+                BFIN_SPORT_UART_MAX_PORTS, 0);
        register_console(&sport_uart_console);
@@ -824,7 +899,7 @@ static int __init sport_uart_init(void)
 {
        int ret;
-        pr_info("Serial: Blackfin uart over sport driver\n");
+        pr_info("Blackfin uart over sport driver\n");
        ret = uart_register_driver(&sport_uart_reg);
        if (ret) {
diff --git a/drivers/serial/bfin_sport_uart.h b/drivers/serial/bfin_sport_uart.h
index abe03614e4df..9ce253e381d2 100644
--- a/drivers/serial/bfin_sport_uart.h
+++ b/drivers/serial/bfin_sport_uart.h
@@ -37,7 +37,21 @@
 #define SPORT_GET_TFSDIV(sport)         bfin_read16(((sport)->port.membase + OFFSET_TFSDIV))
 #define SPORT_GET_TX(sport)             bfin_read16(((sport)->port.membase + OFFSET_TX))
 #define SPORT_GET_RX(sport)             bfin_read16(((sport)->port.membase + OFFSET_RX))
-#define SPORT_GET_RX32(sport)           bfin_read32(((sport)->port.membase + OFFSET_RX))
+/*
+ * If another interrupt fires while doing a 32-bit read from RX FIFO,
+ * a fake RX underflow error will be generated.  So disable interrupts
+ * to prevent interruption while reading the FIFO.
+ */
+#define SPORT_GET_RX32(sport) \
+({ \
+        unsigned int __ret; \
+        if (ANOMALY_05000473) \
+                local_irq_disable(); \
+        __ret = bfin_read32((sport)->port.membase + OFFSET_RX); \
+        if (ANOMALY_05000473) \
+                local_irq_enable(); \
+        __ret; \
+})
 #define SPORT_GET_RCR1(sport)           bfin_read16(((sport)->port.membase + OFFSET_RCR1))
 #define SPORT_GET_RCR2(sport)           bfin_read16(((sport)->port.membase + OFFSET_RCR2))
 #define SPORT_GET_RCLKDIV(sport)        bfin_read16(((sport)->port.membase + OFFSET_RCLKDIV))
@@ -58,4 +72,15 @@
 #define SPORT_TX_FIFO_SIZE      8
+#define SPORT_UART_GET_CTS(x)           gpio_get_value(x->cts_pin)
+#define SPORT_UART_DISABLE_RTS(x)       gpio_set_value(x->rts_pin, 1)
+#define SPORT_UART_ENABLE_RTS(x)        gpio_set_value(x->rts_pin, 0)
+#if defined(CONFIG_SERIAL_BFIN_SPORT0_UART_CTSRTS) \
+        || defined(CONFIG_SERIAL_BFIN_SPORT1_UART_CTSRTS) \
+        || defined(CONFIG_SERIAL_BFIN_SPORT2_UART_CTSRTS) \
+        || defined(CONFIG_SERIAL_BFIN_SPORT3_UART_CTSRTS)
+# define CONFIG_SERIAL_BFIN_SPORT_CTSRTS
+#endif
 #endif /* _BFIN_SPORT_UART_H */
diff --git a/drivers/serial/timbuart.c b/drivers/serial/timbuart.c
index 786ba85c170b..67ca642713b8 100644
--- a/drivers/serial/timbuart.c
+++ b/drivers/serial/timbuart.c
@@ -68,12 +68,22 @@ static void timbuart_start_tx(struct uart_port *port)
        tasklet_schedule(&uart->tasklet);
 }
+static unsigned int timbuart_tx_empty(struct uart_port *port)
+{
+        u32 isr = ioread32(port->membase + TIMBUART_ISR);
+        return (isr & TXBE) ? TIOCSER_TEMT : 0;
+}
 static void timbuart_flush_buffer(struct uart_port *port)
 {
-        u8 ctl = ioread8(port->membase + TIMBUART_CTRL) | TIMBUART_CTRL_FLSHTX;
+        if (!timbuart_tx_empty(port)) {
+                u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |
+                        TIMBUART_CTRL_FLSHTX;
-        iowrite8(ctl, port->membase + TIMBUART_CTRL);
+                iowrite8(ctl, port->membase + TIMBUART_CTRL);
-        iowrite32(TXBF, port->membase + TIMBUART_ISR);
+                iowrite32(TXBF, port->membase + TIMBUART_ISR);
+        }
 }
 static void timbuart_rx_chars(struct uart_port *port)
@@ -195,13 +205,6 @@ void timbuart_tasklet(unsigned long arg)
        dev_dbg(uart->port.dev, "%s leaving\n", __func__);
 }
-static unsigned int timbuart_tx_empty(struct uart_port *port)
-{
-        u32 isr = ioread32(port->membase + TIMBUART_ISR);
-        return (isr & TXBE) ? TIOCSER_TEMT : 0;
-}
 static unsigned int timbuart_get_mctrl(struct uart_port *port)
 {
        u8 cts = ioread8(port->membase + TIMBUART_CTRL);
@@ -220,7 +223,7 @@ static void timbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
        if (mctrl & TIOCM_RTS)
                iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
        else
-                iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
+                iowrite8(0, port->membase + TIMBUART_CTRL);
 }
 static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier)
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index f0a6c61b17f7..e6639a95d276 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -86,7 +86,7 @@ static int ulite_receive(struct uart_port *port, int stat)
        /* stats */
        if (stat & ULITE_STATUS_RXVALID) {
                port->icount.rx++;
-                ch = readb(port->membase + ULITE_RX);
+                ch = ioread32be(port->membase + ULITE_RX);
                if (stat & ULITE_STATUS_PARITY)
                        port->icount.parity++;
@@ -131,7 +131,7 @@ static int ulite_transmit(struct uart_port *port, int stat)
                return 0;
        if (port->x_char) {
-                writeb(port->x_char, port->membase + ULITE_TX);
+                iowrite32be(port->x_char, port->membase + ULITE_TX);
                port->x_char = 0;
                port->icount.tx++;
                return 1;
@@ -140,7 +140,7 @@ static int ulite_transmit(struct uart_port *port, int stat)
        if (uart_circ_empty(xmit) || uart_tx_stopped(port))
                return 0;
-        writeb(xmit->buf[xmit->tail], port->membase + ULITE_TX);
+        iowrite32be(xmit->buf[xmit->tail], port->membase + ULITE_TX);
        xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
        port->icount.tx++;
@@ -157,7 +157,7 @@ static irqreturn_t ulite_isr(int irq, void *dev_id)
        int busy, n = 0;
        do {
-                int stat = readb(port->membase + ULITE_STATUS);
+                int stat = ioread32be(port->membase + ULITE_STATUS);
                busy  = ulite_receive(port, stat);
                busy |= ulite_transmit(port, stat);
                n++;
@@ -178,7 +178,7 @@ static unsigned int ulite_tx_empty(struct uart_port *port)
        unsigned int ret;
        spin_lock_irqsave(&port->lock, flags);
-        ret = readb(port->membase + ULITE_STATUS);
+        ret = ioread32be(port->membase + ULITE_STATUS);
        spin_unlock_irqrestore(&port->lock, flags);
        return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0;
@@ -201,7 +201,7 @@ static void ulite_stop_tx(struct uart_port *port)
 static void ulite_start_tx(struct uart_port *port)
 {
-        ulite_transmit(port, readb(port->membase + ULITE_STATUS));
+        ulite_transmit(port, ioread32be(port->membase + ULITE_STATUS));
 }
 static void ulite_stop_rx(struct uart_port *port)
@@ -230,17 +230,17 @@ static int ulite_startup(struct uart_port *port)
        if (ret)
                return ret;
-        writeb(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX,
+        iowrite32be(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX,
               port->membase + ULITE_CONTROL);
-        writeb(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
+        iowrite32be(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
        return 0;
 }
 static void ulite_shutdown(struct uart_port *port)
 {
-        writeb(0, port->membase + ULITE_CONTROL);
+        iowrite32be(0, port->membase + ULITE_CONTROL);
-        readb(port->membase + ULITE_CONTROL); /* dummy */
+        ioread32be(port->membase + ULITE_CONTROL); /* dummy */
        free_irq(port->irq, port);
 }
@@ -352,7 +352,7 @@ static void ulite_console_wait_tx(struct uart_port *port)
        /* Spin waiting for TX fifo to have space available */
        for (i = 0; i < 100000; i++) {
-                val = readb(port->membase + ULITE_STATUS);
+                val = ioread32be(port->membase + ULITE_STATUS);
                if ((val & ULITE_STATUS_TXFULL) == 0)
                        break;
                cpu_relax();
@@ -362,7 +362,7 @@ static void ulite_console_wait_tx(struct uart_port *port)
 static void ulite_console_putchar(struct uart_port *port, int ch)
 {
        ulite_console_wait_tx(port);
-        writeb(ch, port->membase + ULITE_TX);
+        iowrite32be(ch, port->membase + ULITE_TX);
 }
 static void ulite_console_write(struct console *co, const char *s,
@@ -379,8 +379,8 @@ static void ulite_console_write(struct console *co, const char *s,
                spin_lock_irqsave(&port->lock, flags);
        /* save and disable interrupt */
-        ier = readb(port->membase + ULITE_STATUS) & ULITE_STATUS_IE;
+        ier = ioread32be(port->membase + ULITE_STATUS) & ULITE_STATUS_IE;
-        writeb(0, port->membase + ULITE_CONTROL);
+        iowrite32be(0, port->membase + ULITE_CONTROL);
        uart_console_write(port, s, count, ulite_console_putchar);
@@ -388,7 +388,7 @@ static void ulite_console_write(struct console *co, const char *s,
        /* restore interrupt state */
        if (ier)
-                writeb(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
+                iowrite32be(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
        if (locked)
                spin_unlock_irqrestore(&port->lock, flags);
@@ -601,7 +601,7 @@ ulite_of_probe(struct of_device *op, const struct of_device_id *match)
        id = of_get_property(op->node, "port-number", NULL);
-        return ulite_assign(&op->dev, id ? *id : -1, res.start+3, irq);
+        return ulite_assign(&op->dev, id ? *id : -1, res.start, irq);
 }
 static int __devexit ulite_of_remove(struct of_device *op)
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index a191fa2be7c5..f950b6316949 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -180,10 +180,10 @@ config SPI_OMAP_UWIRE
          This hooks up to the MicroWire controller on OMAP1 chips.
 config SPI_OMAP24XX
-        tristate "McSPI driver for OMAP24xx/OMAP34xx"
+        tristate "McSPI driver for OMAP"
-        depends on ARCH_OMAP2 || ARCH_OMAP3
+        depends on ARCH_OMAP2PLUS
        help
-          SPI master controller for OMAP24xx/OMAP34xx Multichannel SPI
+          SPI master controller for OMAP24XX and later Multichannel SPI
          (McSPI) modules.
 config SPI_OMAP_100K
diff --git a/drivers/staging/comedi/drivers/quatech_daqp_cs.c b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
index 1786db2f3378..8b274b708259 100644
--- a/drivers/staging/comedi/drivers/quatech_daqp_cs.c
+++ b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
@@ -48,6 +48,7 @@ Devices: [Quatech] DAQP-208 (daqp), DAQP-308
 */
 #include "../comedidev.h"
+#include <linux/semaphore.h>
 #include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
diff --git a/drivers/staging/udlfb/udlfb.c b/drivers/staging/udlfb/udlfb.c
index aa8195199a2c..577f2bf6eb23 100644
--- a/drivers/staging/udlfb/udlfb.c
+++ b/drivers/staging/udlfb/udlfb.c
@@ -1063,7 +1063,8 @@ static ssize_t metrics_misc_show(struct device *fbdev,
                        atomic_read(&dev->lost_pixels) ? "yes" : "no");
 }
-static ssize_t edid_show(struct kobject *kobj, struct bin_attribute *a,
+static ssize_t edid_show(struct file *filp, struct kobject *kobj,
+                         struct bin_attribute *a,
                         char *buf, loff_t off, size_t count) {
        struct device *fbdev = container_of(kobj, struct device, kobj);
        struct fb_info *fb_info = dev_get_drvdata(fbdev);
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 06863befaf3a..448f5b47fc48 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -658,7 +658,8 @@ const struct attribute_group *usb_device_groups[] = {
 /* Binary descriptors */
 static ssize_t
-read_descriptors(struct kobject *kobj, struct bin_attribute *attr,
+read_descriptors(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                char *buf, loff_t off, size_t count)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 397b678f1c47..5ae14f6c1e7a 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -573,7 +573,7 @@ int usb_lock_device_for_reset(struct usb_device *udev,
                        iface->condition == USB_INTERFACE_UNBOUND))
                return -EINTR;
-        while (usb_trylock_device(udev) != 0) {
+        while (!usb_trylock_device(udev)) {
                /* If we can't acquire the lock after waiting one second,
                 * we're probably deadlocked */
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 6c37e8ee5efe..3c1e13ed1cba 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -2099,7 +2099,7 @@ static ssize_t radeon_show_one_edid(char *buf, loff_t off, size_t count, const u
 }
-static ssize_t radeon_show_edid1(struct kobject *kobj,
+static ssize_t radeon_show_edid1(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t off, size_t count)
 {
@@ -2112,7 +2112,7 @@ static ssize_t radeon_show_edid1(struct kobject *kobj,
 }
-static ssize_t radeon_show_edid2(struct kobject *kobj,
+static ssize_t radeon_show_edid2(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/w1/slaves/w1_ds2431.c b/drivers/w1/slaves/w1_ds2431.c
index 2c6c0cf6a20f..84e2410aec1d 100644
--- a/drivers/w1/slaves/w1_ds2431.c
+++ b/drivers/w1/slaves/w1_ds2431.c
@@ -96,7 +96,7 @@ static int w1_f2d_readblock(struct w1_slave *sl, int off, int count, char *buf)
        return -1;
 }
-static ssize_t w1_f2d_read_bin(struct kobject *kobj,
+static ssize_t w1_f2d_read_bin(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
@@ -202,7 +202,7 @@ retry:
        return 0;
 }
-static ssize_t w1_f2d_write_bin(struct kobject *kobj,
+static ssize_t w1_f2d_write_bin(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/w1/slaves/w1_ds2433.c b/drivers/w1/slaves/w1_ds2433.c
index d2bf32118a98..0f7b8f9c509a 100644
--- a/drivers/w1/slaves/w1_ds2433.c
+++ b/drivers/w1/slaves/w1_ds2433.c
@@ -92,7 +92,7 @@ static int w1_f23_refresh_block(struct w1_slave *sl, struct w1_f23_data *data,
 }
 #endif  /* CONFIG_W1_SLAVE_DS2433_CRC */
-static ssize_t w1_f23_read_bin(struct kobject *kobj,
+static ssize_t w1_f23_read_bin(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
@@ -206,7 +206,7 @@ static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data)
        return 0;
 }
-static ssize_t w1_f23_write_bin(struct kobject *kobj,
+static ssize_t w1_f23_write_bin(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/w1/slaves/w1_ds2760.c b/drivers/w1/slaves/w1_ds2760.c
index 6e153343e117..483d45180911 100644
--- a/drivers/w1/slaves/w1_ds2760.c
+++ b/drivers/w1/slaves/w1_ds2760.c
@@ -97,7 +97,7 @@ int w1_ds2760_recall_eeprom(struct device *dev, int addr)
        return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_RECALL_DATA);
 }
-static ssize_t w1_ds2760_read_bin(struct kobject *kobj,
+static ssize_t w1_ds2760_read_bin(struct file *filp, struct kobject *kobj,
                                  struct bin_attribute *bin_attr,
                                  char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index ad5897dc4495..2839e281cd65 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -120,7 +120,7 @@ static struct device_attribute w1_slave_attr_id =
 /* Default family */
-static ssize_t w1_default_write(struct kobject *kobj,
+static ssize_t w1_default_write(struct file *filp, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t off, size_t count)
 {
@@ -139,7 +139,7 @@ out_up:
        return count;
 }
-static ssize_t w1_default_read(struct kobject *kobj,
+static ssize_t w1_default_read(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
diff --git a/drivers/zorro/zorro-sysfs.c b/drivers/zorro/zorro-sysfs.c
index eb924e0a64ce..26f7184ef9e1 100644
--- a/drivers/zorro/zorro-sysfs.c
+++ b/drivers/zorro/zorro-sysfs.c
@@ -49,7 +49,7 @@ static ssize_t zorro_show_resource(struct device *dev, struct device_attribute *
 static DEVICE_ATTR(resource, S_IRUGO, zorro_show_resource, NULL);
-static ssize_t zorro_read_config(struct kobject *kobj,
+static ssize_t zorro_read_config(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t off, size_t count)
 {