167 files changed, 16780 insertions, 6424 deletions

diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 652281402c92..5bfa2e9a7c26 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -28,6 +28,7 @@ enum {
         FW_STATUS_DONE,
         FW_STATUS_ABORT,
         FW_STATUS_READY,
+        FW_STATUS_READY_NOHOTPLUG,
 };
 
 static int loading_timeout = 10;        /* In seconds */
@@ -344,7 +345,7 @@ error_kfree:
 
 static int
 fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p,
-                      const char *fw_name, struct device *device)
+                      const char *fw_name, struct device *device, int hotplug)
 {
         struct class_device *class_dev;
         struct firmware_priv *fw_priv;
@@ -376,7 +377,10 @@ fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p,
                 goto error_unreg;
         }
 
-        set_bit(FW_STATUS_READY, &fw_priv->status);
+        if (hotplug)
+                set_bit(FW_STATUS_READY, &fw_priv->status);
+        else
+                set_bit(FW_STATUS_READY_NOHOTPLUG, &fw_priv->status);
         *class_dev_p = class_dev;
         goto out;
 
@@ -386,21 +390,9 @@ out:
         return retval;
 }
 
-/**
- * request_firmware: - request firmware to hotplug and wait for it
- * Description:
- *      @firmware will be used to return a firmware image by the name
- *      of @name for device @device.
- *
- *      Should be called from user context where sleeping is allowed.
- *
- *      @name will be use as $FIRMWARE in the hotplug environment and
- *      should be distinctive enough not to be confused with any other
- *      firmware image for this or any other device.
- **/
-int
-request_firmware(const struct firmware **firmware_p, const char *name,
-                 struct device *device)
+static int
+_request_firmware(const struct firmware **firmware_p, const char *name,
+                 struct device *device, int hotplug)
 {
         struct class_device *class_dev;
         struct firmware_priv *fw_priv;
@@ -419,22 +411,25 @@ request_firmware(const struct firmware **firmware_p, const char *name,
         }
         memset(firmware, 0, sizeof (*firmware));
 
-        retval = fw_setup_class_device(firmware, &class_dev, name, device);
+        retval = fw_setup_class_device(firmware, &class_dev, name, device,
+                hotplug);
         if (retval)
                 goto error_kfree_fw;
 
         fw_priv = class_get_devdata(class_dev);
 
-        if (loading_timeout > 0) {
-                fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
-                add_timer(&fw_priv->timeout);
-        }
-
-        kobject_hotplug(&class_dev->kobj, KOBJ_ADD);
-        wait_for_completion(&fw_priv->completion);
-        set_bit(FW_STATUS_DONE, &fw_priv->status);
+        if (hotplug) {
+                if (loading_timeout > 0) {
+                        fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
+                        add_timer(&fw_priv->timeout);
+                }
 
-        del_timer_sync(&fw_priv->timeout);
+                kobject_hotplug(&class_dev->kobj, KOBJ_ADD);
+                wait_for_completion(&fw_priv->completion);
+                set_bit(FW_STATUS_DONE, &fw_priv->status);
+                del_timer_sync(&fw_priv->timeout);
+        } else
+                wait_for_completion(&fw_priv->completion);
 
         down(&fw_lock);
         if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status)) {
@@ -455,6 +450,26 @@ out:
 }
 
 /**
+ * request_firmware: - request firmware to hotplug and wait for it
+ * Description:
+ *      @firmware will be used to return a firmware image by the name
+ *      of @name for device @device.
+ *
+ *      Should be called from user context where sleeping is allowed.
+ *
+ *      @name will be use as $FIRMWARE in the hotplug environment and
+ *      should be distinctive enough not to be confused with any other
+ *      firmware image for this or any other device.
+ **/
+int
+request_firmware(const struct firmware **firmware_p, const char *name,
+                 struct device *device)
+{
+        int hotplug = 1;
+        return _request_firmware(firmware_p, name, device, hotplug);
+}
+
+/**
  * release_firmware: - release the resource associated with a firmware image
  **/
 void
@@ -491,6 +506,7 @@ struct firmware_work {
         struct device *device;
         void *context;
         void (*cont)(const struct firmware *fw, void *context);
+        int hotplug;
 };
 
 static int
@@ -503,7 +519,8 @@ request_firmware_work_func(void *arg)
                 return 0;
         }
         daemonize("%s/%s", "firmware", fw_work->name);
-        request_firmware(&fw, fw_work->name, fw_work->device);
+        _request_firmware(&fw, fw_work->name, fw_work->device,
+                fw_work->hotplug);
         fw_work->cont(fw, fw_work->context);
         release_firmware(fw);
         module_put(fw_work->module);
@@ -518,6 +535,9 @@ request_firmware_work_func(void *arg)
  *      Asynchronous variant of request_firmware() for contexts where
  *      it is not possible to sleep.
  *
+ *      @hotplug invokes hotplug event to copy the firmware image if this flag
+ *      is non-zero else the firmware copy must be done manually.
+ *
  *      @cont will be called asynchronously when the firmware request is over.
  *
  *      @context will be passed over to @cont.
@@ -527,7 +547,7 @@ request_firmware_work_func(void *arg)
  **/
 int
 request_firmware_nowait(
-        struct module *module,
+        struct module *module, int hotplug,
         const char *name, struct device *device, void *context,
         void (*cont)(const struct firmware *fw, void *context))
 {
@@ -548,6 +568,7 @@ request_firmware_nowait(
                 .device = device,
                 .context = context,
                 .cont = cont,
+                .hotplug = hotplug,
         };
 
         ret = kernel_thread(request_firmware_work_func, fw_work,
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 6b736364cc5b..51b0af1cebee 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -6,7 +6,7 @@ menu "Block devices"
 
 config BLK_DEV_FD
         tristate "Normal floppy disk support"
-        depends on (!ARCH_S390 && !M68K && !IA64 && !UML && !ARM) || Q40 || (SUN3X && BROKEN) || ARCH_RPC || ARCH_EBSA285
+        depends on ARCH_MAY_HAVE_PC_FDC
         ---help---
           If you want to use the floppy disk drive(s) of your PC under Linux,
           say Y. Information about this driver, especially important for IBM
diff --git a/drivers/block/aoe/aoedev.c b/drivers/block/aoe/aoedev.c
index 6e231c5a1199..ded33ba31acc 100644
--- a/drivers/block/aoe/aoedev.c
+++ b/drivers/block/aoe/aoedev.c
@@ -35,7 +35,7 @@ aoedev_newdev(ulong nframes)
         struct aoedev *d;
         struct frame *f, *e;
 
-        d = kcalloc(1, sizeof *d, GFP_ATOMIC);
+        d = kzalloc(sizeof *d, GFP_ATOMIC);
         if (d == NULL)
                 return NULL;
         f = kcalloc(nframes, sizeof *f, GFP_ATOMIC);
diff --git a/drivers/block/cfq-iosched.c b/drivers/block/cfq-iosched.c
index cd056e7e64ec..30c0903c7cdd 100644
--- a/drivers/block/cfq-iosched.c
+++ b/drivers/block/cfq-iosched.c
@@ -2260,8 +2260,6 @@ static void cfq_put_cfqd(struct cfq_data *cfqd)
         if (!atomic_dec_and_test(&cfqd->ref))
                 return;
 
-        blk_put_queue(q);
-
         cfq_shutdown_timer_wq(cfqd);
         q->elevator->elevator_data = NULL;
 
@@ -2318,7 +2316,6 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e)
         e->elevator_data = cfqd;
 
         cfqd->queue = q;
-        atomic_inc(&q->refcnt);
 
         cfqd->max_queued = q->nr_requests / 4;
         q->nr_batching = cfq_queued;
diff --git a/drivers/block/deadline-iosched.c b/drivers/block/deadline-iosched.c
index ff5201e02153..24594c57c323 100644
--- a/drivers/block/deadline-iosched.c
+++ b/drivers/block/deadline-iosched.c
@@ -507,18 +507,12 @@ static int deadline_dispatch_requests(struct deadline_data *dd)
         const int reads = !list_empty(&dd->fifo_list[READ]);
         const int writes = !list_empty(&dd->fifo_list[WRITE]);
         struct deadline_rq *drq;
-        int data_dir, other_dir;
+        int data_dir;
 
         /*
          * batches are currently reads XOR writes
          */
-        drq = NULL;
-
-        if (dd->next_drq[READ])
-                drq = dd->next_drq[READ];
-
-        if (dd->next_drq[WRITE])
-                drq = dd->next_drq[WRITE];
+        drq = dd->next_drq[WRITE] ? : dd->next_drq[READ];
 
         if (drq) {
                 /* we have a "next request" */
@@ -544,7 +538,6 @@ static int deadline_dispatch_requests(struct deadline_data *dd)
                         goto dispatch_writes;
 
                 data_dir = READ;
-                other_dir = WRITE;
 
                 goto dispatch_find_request;
         }
@@ -560,7 +553,6 @@ dispatch_writes:
                 dd->starved = 0;
 
                 data_dir = WRITE;
-                other_dir = READ;
 
                 goto dispatch_find_request;
         }
diff --git a/drivers/block/genhd.c b/drivers/block/genhd.c
index 47fd3659a061..d42840cc0d1d 100644
--- a/drivers/block/genhd.c
+++ b/drivers/block/genhd.c
@@ -45,7 +45,7 @@ int get_blkdev_list(char *p, int used)
         struct blk_major_name *n;
         int i, len;
 
-        len = sprintf(p, "\nBlock devices:\n");
+        len = snprintf(p, (PAGE_SIZE-used), "\nBlock devices:\n");
 
         down(&block_subsys_sem);
         for (i = 0; i < ARRAY_SIZE(major_names); i++) {
diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index 3c818544475e..b4b17958d101 100644
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -235,8 +235,8 @@ void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn)
          * set defaults
          */
         q->nr_requests = BLKDEV_MAX_RQ;
-        q->max_phys_segments = MAX_PHYS_SEGMENTS;
-        q->max_hw_segments = MAX_HW_SEGMENTS;
+        blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);
+        blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);
         q->make_request_fn = mfn;
         q->backing_dev_info.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
         q->backing_dev_info.state = 0;
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index a1de06d76de6..2bc9d64db106 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -138,7 +138,7 @@ config CYZ_INTR
 
 config DIGIEPCA
         tristate "Digiboard Intelligent Async Support"
-        depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP && (!64BIT || BROKEN)
+        depends on SERIAL_NONSTANDARD
         ---help---
           This is a driver for Digi International's Xx, Xeve, and Xem series
           of cards which provide multiple serial ports. You would need
diff --git a/drivers/char/digi1.h b/drivers/char/digi1.h
index 184378d23f8c..94d4eab5d3ca 100644
--- a/drivers/char/digi1.h
+++ b/drivers/char/digi1.h
@@ -1,46 +1,46 @@
 /*          Definitions for DigiBoard ditty(1) command.                 */
 
 #if !defined(TIOCMODG)
-#define TIOCMODG        ('d'<<8) | 250          /* get modem ctrl state */
-#define TIOCMODS        ('d'<<8) | 251          /* set modem ctrl state */
+#define TIOCMODG        (('d'<<8) | 250)        /* get modem ctrl state */
+#define TIOCMODS        (('d'<<8) | 251)        /* set modem ctrl state */
 #endif
 
 #if !defined(TIOCMSET)
-#define TIOCMSET        ('d'<<8) | 252          /* set modem ctrl state */
-#define TIOCMGET        ('d'<<8) | 253          /* set modem ctrl state */
+#define TIOCMSET        (('d'<<8) | 252)        /* set modem ctrl state */
+#define TIOCMGET        (('d'<<8) | 253)        /* set modem ctrl state */
 #endif
 
 #if !defined(TIOCMBIC)
-#define TIOCMBIC        ('d'<<8) | 254          /* set modem ctrl state */
-#define TIOCMBIS        ('d'<<8) | 255          /* set modem ctrl state */
+#define TIOCMBIC        (('d'<<8) | 254)        /* set modem ctrl state */
+#define TIOCMBIS        (('d'<<8) | 255)        /* set modem ctrl state */
 #endif
 
 #if !defined(TIOCSDTR)
-#define TIOCSDTR        ('e'<<8) | 0            /* set DTR              */
-#define TIOCCDTR        ('e'<<8) | 1            /* clear DTR            */
+#define TIOCSDTR        (('e'<<8) | 0)          /* set DTR              */
+#define TIOCCDTR        (('e'<<8) | 1)          /* clear DTR            */
 #endif
 
 /************************************************************************
  * Ioctl command arguments for DIGI parameters.
  ************************************************************************/
-#define DIGI_GETA       ('e'<<8) | 94           /* Read params          */
+#define DIGI_GETA       (('e'<<8) | 94)         /* Read params          */
 
-#define DIGI_SETA       ('e'<<8) | 95           /* Set params           */
-#define DIGI_SETAW      ('e'<<8) | 96           /* Drain & set params   */
-#define DIGI_SETAF      ('e'<<8) | 97           /* Drain, flush & set params */
+#define DIGI_SETA       (('e'<<8) | 95)         /* Set params           */
+#define DIGI_SETAW      (('e'<<8) | 96)         /* Drain & set params   */
+#define DIGI_SETAF      (('e'<<8) | 97)         /* Drain, flush & set params */
 
-#define DIGI_GETFLOW    ('e'<<8) | 99           /* Get startc/stopc flow */
+#define DIGI_GETFLOW    (('e'<<8) | 99)         /* Get startc/stopc flow */
                                                 /* control characters    */
-#define DIGI_SETFLOW    ('e'<<8) | 100          /* Set startc/stopc flow */
+#define DIGI_SETFLOW    (('e'<<8) | 100)        /* Set startc/stopc flow */
                                                 /* control characters    */
-#define DIGI_GETAFLOW   ('e'<<8) | 101          /* Get Aux. startc/stopc */
+#define DIGI_GETAFLOW   (('e'<<8) | 101)        /* Get Aux. startc/stopc */
                                                 /* flow control chars    */
-#define DIGI_SETAFLOW   ('e'<<8) | 102          /* Set Aux. startc/stopc */
+#define DIGI_SETAFLOW   (('e'<<8) | 102)        /* Set Aux. startc/stopc */
                                                 /* flow control chars    */
 
-#define DIGI_GETINFO    ('e'<<8) | 103          /* Fill in digi_info */
-#define DIGI_POLLER     ('e'<<8) | 104          /* Turn on/off poller */
-#define DIGI_INIT       ('e'<<8) | 105          /* Allow things to run. */
+#define DIGI_GETINFO    (('e'<<8) | 103)        /* Fill in digi_info */
+#define DIGI_POLLER     (('e'<<8) | 104)        /* Turn on/off poller */
+#define DIGI_INIT       (('e'<<8) | 105)        /* Allow things to run. */
 
 struct  digiflow_struct 
 {
diff --git a/drivers/char/digiFep1.h b/drivers/char/digiFep1.h
index c47d7fcb8400..3c1f1922c798 100644
--- a/drivers/char/digiFep1.h
+++ b/drivers/char/digiFep1.h
@@ -13,88 +13,88 @@
 
 struct global_data 
 {
-        volatile ushort cin;
-        volatile ushort cout;
-        volatile ushort cstart;
-        volatile ushort cmax;
-        volatile ushort ein;
-        volatile ushort eout;
-        volatile ushort istart;
-        volatile ushort imax;
+        u16 cin;
+        u16 cout;
+        u16 cstart;
+        u16 cmax;
+        u16 ein;
+        u16 eout;
+        u16 istart;
+        u16 imax;
 };
 
 
 struct board_chan 
 {
-        int filler1; 
-        int filler2;
-        volatile ushort tseg;
-        volatile ushort tin;
-        volatile ushort tout;
-        volatile ushort tmax;
-        
-        volatile ushort rseg;
-        volatile ushort rin;
-        volatile ushort rout;
-        volatile ushort rmax;
-        
-        volatile ushort tlow;
-        volatile ushort rlow;
-        volatile ushort rhigh;
-        volatile ushort incr;
-        
-        volatile ushort etime;
-        volatile ushort edelay;
-        volatile unchar *dev;
-        
-        volatile ushort iflag;
-        volatile ushort oflag;
-        volatile ushort cflag;
-        volatile ushort gmask;
-        
-        volatile ushort col;
-        volatile ushort delay;
-        volatile ushort imask;
-        volatile ushort tflush;
-
-        int filler3;
-        int filler4;
-        int filler5;
-        int filler6;
-        
-        volatile unchar num;
-        volatile unchar ract;
-        volatile unchar bstat;
-        volatile unchar tbusy;
-        volatile unchar iempty;
-        volatile unchar ilow;
-        volatile unchar idata;
-        volatile unchar eflag;
-        
-        volatile unchar tflag;
-        volatile unchar rflag;
-        volatile unchar xmask;
-        volatile unchar xval;
-        volatile unchar mstat;
-        volatile unchar mchange;
-        volatile unchar mint;
-        volatile unchar lstat;
-
-        volatile unchar mtran;
-        volatile unchar orun;
-        volatile unchar startca;
-        volatile unchar stopca;
-        volatile unchar startc;
-        volatile unchar stopc;
-        volatile unchar vnext;
-        volatile unchar hflow;
-
-        volatile unchar fillc;
-        volatile unchar ochar;
-        volatile unchar omask;
-
-        unchar filler7;
-        unchar filler8[28];
+        u32 filler1;
+        u32 filler2;
+        u16 tseg;
+        u16 tin;
+        u16 tout;
+        u16 tmax;
+
+        u16 rseg;
+        u16 rin;
+        u16 rout;
+        u16 rmax;
+
+        u16 tlow;
+        u16 rlow;
+        u16 rhigh;
+        u16 incr;
+
+        u16 etime;
+        u16 edelay;
+        unchar *dev;
+
+        u16 iflag;
+        u16 oflag;
+        u16 cflag;
+        u16 gmask;
+
+        u16 col;
+        u16 delay;
+        u16 imask;
+        u16 tflush;
+
+        u32 filler3;
+        u32 filler4;
+        u32 filler5;
+        u32 filler6;
+
+        u8 num;
+        u8 ract;
+        u8 bstat;
+        u8 tbusy;
+        u8 iempty;
+        u8 ilow;
+        u8 idata;
+        u8 eflag;
+
+        u8 tflag;
+        u8 rflag;
+        u8 xmask;
+        u8 xval;
+        u8 mstat;
+        u8 mchange;
+        u8 mint;
+        u8 lstat;
+
+        u8 mtran;
+        u8 orun;
+        u8 startca;
+        u8 stopca;
+        u8 startc;
+        u8 stopc;
+        u8 vnext;
+        u8 hflow;
+
+        u8 fillc;
+        u8 ochar;
+        u8 omask;
+
+        u8 filler7;
+        u8 filler8[28];
 }; 
 
 
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 6025e1866c7e..58d3738a2b7f 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -6,6 +6,8 @@
         For technical support please email digiLinux@dgii.com or
         call Digi tech support at (612) 912-3456
 
+        ** This driver is no longer supported by Digi **
+
         Much of this design and code came from epca.c which was 
         copyright (C) 1994, 1995 Troy De Jongh, and subsquently 
         modified by David Nugent, Christoph Lameter, Mike McLagan. 
@@ -43,31 +45,19 @@
 #include <linux/interrupt.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
-
-#ifdef CONFIG_PCI
-#define ENABLE_PCI
-#endif /* CONFIG_PCI */
-
-#define putUser(arg1, arg2) put_user(arg1, (unsigned long __user *)arg2)
-#define getUser(arg1, arg2) get_user(arg1, (unsigned __user *)arg2)
-
-#ifdef ENABLE_PCI
+#include <linux/spinlock.h>
 #include <linux/pci.h>
 #include "digiPCI.h"
-#endif /* ENABLE_PCI */
+
 
 #include "digi1.h"
 #include "digiFep1.h"
 #include "epca.h"
 #include "epcaconfig.h"
 
-#if BITS_PER_LONG != 32
-#  error FIXME: this driver only works on 32-bit platforms
-#endif
-
 /* ---------------------- Begin defines ------------------------ */
 
-#define VERSION            "1.3.0.1-LK"
+#define VERSION            "1.3.0.1-LK2.6"
 
 /* This major needs to be submitted to Linux to join the majors list */
 
@@ -81,13 +71,17 @@
 
 /* ----------------- Begin global definitions ------------------- */
 
-static char mesg[100];
 static int nbdevs, num_cards, liloconfig;
 static int digi_poller_inhibited = 1 ;
 
 static int setup_error_code;
 static int invalid_lilo_config;
 
+/* The ISA boards do window flipping into the same spaces so its only sane
+   with a single lock. It's still pretty efficient */
+
+static spinlock_t epca_lock = SPIN_LOCK_UNLOCKED;
+
 /* -----------------------------------------------------------------------
         MAXBOARDS is typically 12, but ISA and EISA cards are restricted to 
         7 below.
@@ -129,58 +123,58 @@ static struct timer_list epca_timer;
         configured.
 ----------------------------------------------------------------------- */
         
-static inline void memwinon(struct board_info *b, unsigned int win);
-static inline void memwinoff(struct board_info *b, unsigned int win);
-static inline void globalwinon(struct channel *ch);
-static inline void rxwinon(struct channel *ch);
-static inline void txwinon(struct channel *ch);
-static inline void memoff(struct channel *ch);
-static inline void assertgwinon(struct channel *ch);
-static inline void assertmemoff(struct channel *ch);
+static void memwinon(struct board_info *b, unsigned int win);
+static void memwinoff(struct board_info *b, unsigned int win);
+static void globalwinon(struct channel *ch);
+static void rxwinon(struct channel *ch);
+static void txwinon(struct channel *ch);
+static void memoff(struct channel *ch);
+static void assertgwinon(struct channel *ch);
+static void assertmemoff(struct channel *ch);
 
 /* ---- Begin more 'specific' memory functions for cx_like products --- */
 
-static inline void pcxem_memwinon(struct board_info *b, unsigned int win);
-static inline void pcxem_memwinoff(struct board_info *b, unsigned int win);
-static inline void pcxem_globalwinon(struct channel *ch);
-static inline void pcxem_rxwinon(struct channel *ch);
-static inline void pcxem_txwinon(struct channel *ch);
-static inline void pcxem_memoff(struct channel *ch);
+static void pcxem_memwinon(struct board_info *b, unsigned int win);
+static void pcxem_memwinoff(struct board_info *b, unsigned int win);
+static void pcxem_globalwinon(struct channel *ch);
+static void pcxem_rxwinon(struct channel *ch);
+static void pcxem_txwinon(struct channel *ch);
+static void pcxem_memoff(struct channel *ch);
 
 /* ------ Begin more 'specific' memory functions for the pcxe ------- */
 
-static inline void pcxe_memwinon(struct board_info *b, unsigned int win);
-static inline void pcxe_memwinoff(struct board_info *b, unsigned int win);
-static inline void pcxe_globalwinon(struct channel *ch);
-static inline void pcxe_rxwinon(struct channel *ch);
-static inline void pcxe_txwinon(struct channel *ch);
-static inline void pcxe_memoff(struct channel *ch);
+static void pcxe_memwinon(struct board_info *b, unsigned int win);
+static void pcxe_memwinoff(struct board_info *b, unsigned int win);
+static void pcxe_globalwinon(struct channel *ch);
+static void pcxe_rxwinon(struct channel *ch);
+static void pcxe_txwinon(struct channel *ch);
+static void pcxe_memoff(struct channel *ch);
 
 /* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
 /* Note : pc64xe and pcxi share the same windowing routines */
 
-static inline void pcxi_memwinon(struct board_info *b, unsigned int win);
-static inline void pcxi_memwinoff(struct board_info *b, unsigned int win);
-static inline void pcxi_globalwinon(struct channel *ch);
-static inline void pcxi_rxwinon(struct channel *ch);
-static inline void pcxi_txwinon(struct channel *ch);
-static inline void pcxi_memoff(struct channel *ch);
+static void pcxi_memwinon(struct board_info *b, unsigned int win);
+static void pcxi_memwinoff(struct board_info *b, unsigned int win);
+static void pcxi_globalwinon(struct channel *ch);
+static void pcxi_rxwinon(struct channel *ch);
+static void pcxi_txwinon(struct channel *ch);
+static void pcxi_memoff(struct channel *ch);
 
 /* - Begin 'specific' do nothing memory functions needed for some cards - */
 
-static inline void dummy_memwinon(struct board_info *b, unsigned int win);
-static inline void dummy_memwinoff(struct board_info *b, unsigned int win);
-static inline void dummy_globalwinon(struct channel *ch);
-static inline void dummy_rxwinon(struct channel *ch);
-static inline void dummy_txwinon(struct channel *ch);
-static inline void dummy_memoff(struct channel *ch);
-static inline void dummy_assertgwinon(struct channel *ch);
-static inline void dummy_assertmemoff(struct channel *ch);
+static void dummy_memwinon(struct board_info *b, unsigned int win);
+static void dummy_memwinoff(struct board_info *b, unsigned int win);
+static void dummy_globalwinon(struct channel *ch);
+static void dummy_rxwinon(struct channel *ch);
+static void dummy_txwinon(struct channel *ch);
+static void dummy_memoff(struct channel *ch);
+static void dummy_assertgwinon(struct channel *ch);
+static void dummy_assertmemoff(struct channel *ch);
 
 /* ------------------- Begin declare functions ----------------------- */
 
-static inline struct channel *verifyChannel(register struct tty_struct *);
-static inline void pc_sched_event(struct channel *, int);
+static struct channel *verifyChannel(struct tty_struct *);
+static void pc_sched_event(struct channel *, int);
 static void epca_error(int, char *);
 static void pc_close(struct tty_struct *, struct file *);
 static void shutdown(struct channel *);
@@ -215,15 +209,11 @@ static void pc_unthrottle(struct tty_struct *tty);
 static void digi_send_break(struct channel *ch, int msec);
 static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
 void epca_setup(char *, int *);
-void console_print(const char *);
 
 static int get_termio(struct tty_struct *, struct termio __user *);
 static int pc_write(struct tty_struct *, const unsigned char *, int);
-int pc_init(void);
-
-#ifdef ENABLE_PCI
+static int pc_init(void);
 static int init_PCI(void);
-#endif /* ENABLE_PCI */
 
 
 /* ------------------------------------------------------------------
@@ -237,41 +227,41 @@ static int init_PCI(void);
         making direct calls deserves what they get.
 -------------------------------------------------------------------- */
 
-static inline void memwinon(struct board_info *b, unsigned int win)
+static void memwinon(struct board_info *b, unsigned int win)
 {
         (b->memwinon)(b, win);
 }
 
-static inline void memwinoff(struct board_info *b, unsigned int win)
+static void memwinoff(struct board_info *b, unsigned int win)
 {
         (b->memwinoff)(b, win);
 }
 
-static inline void globalwinon(struct channel *ch)
+static void globalwinon(struct channel *ch)
 {
         (ch->board->globalwinon)(ch);
 }
 
-static inline void rxwinon(struct channel *ch)
+static void rxwinon(struct channel *ch)
 {
         (ch->board->rxwinon)(ch);
 }
 
-static inline void txwinon(struct channel *ch)
+static void txwinon(struct channel *ch)
 {
         (ch->board->txwinon)(ch);
 }
 
-static inline void memoff(struct channel *ch)
+static void memoff(struct channel *ch)
 {
         (ch->board->memoff)(ch);
 }
-static inline void assertgwinon(struct channel *ch)
+static void assertgwinon(struct channel *ch)
 {
         (ch->board->assertgwinon)(ch);
 }
 
-static inline void assertmemoff(struct channel *ch)
+static void assertmemoff(struct channel *ch)
 {
         (ch->board->assertmemoff)(ch);
 }
@@ -281,66 +271,66 @@ static inline void assertmemoff(struct channel *ch)
         and CX series cards.
 ------------------------------------------------------------ */
 
-static inline void pcxem_memwinon(struct board_info *b, unsigned int win)
+static void pcxem_memwinon(struct board_info *b, unsigned int win)
 {
-        outb_p(FEPWIN|win, (int)b->port + 1);
+        outb_p(FEPWIN|win, b->port + 1);
 }
 
-static inline void pcxem_memwinoff(struct board_info *b, unsigned int win)
+static void pcxem_memwinoff(struct board_info *b, unsigned int win)
 {
-        outb_p(0, (int)b->port + 1);
+        outb_p(0, b->port + 1);
 }
 
-static inline void pcxem_globalwinon(struct channel *ch)
+static void pcxem_globalwinon(struct channel *ch)
 {
         outb_p( FEPWIN, (int)ch->board->port + 1);
 }
 
-static inline void pcxem_rxwinon(struct channel *ch)
+static void pcxem_rxwinon(struct channel *ch)
 {
         outb_p(ch->rxwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxem_txwinon(struct channel *ch)
+static void pcxem_txwinon(struct channel *ch)
 {
         outb_p(ch->txwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxem_memoff(struct channel *ch)
+static void pcxem_memoff(struct channel *ch)
 {
         outb_p(0, (int)ch->board->port + 1);
 }
 
 /* ----------------- Begin pcxe memory window stuff ------------------ */
 
-static inline void pcxe_memwinon(struct board_info *b, unsigned int win)
+static void pcxe_memwinon(struct board_info *b, unsigned int win)
 {
-               outb_p(FEPWIN | win, (int)b->port + 1);
+               outb_p(FEPWIN | win, b->port + 1);
 }
 
-static inline void pcxe_memwinoff(struct board_info *b, unsigned int win)
+static void pcxe_memwinoff(struct board_info *b, unsigned int win)
 {
-        outb_p(inb((int)b->port) & ~FEPMEM,
-                   (int)b->port + 1);
-        outb_p(0, (int)b->port + 1);
+        outb_p(inb(b->port) & ~FEPMEM,
+                   b->port + 1);
+        outb_p(0, b->port + 1);
 }
 
-static inline void pcxe_globalwinon(struct channel *ch)
+static void pcxe_globalwinon(struct channel *ch)
 {
         outb_p( FEPWIN, (int)ch->board->port + 1);
 }
 
-static inline void pcxe_rxwinon(struct channel *ch)
+static void pcxe_rxwinon(struct channel *ch)
 {
                 outb_p(ch->rxwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxe_txwinon(struct channel *ch)
+static void pcxe_txwinon(struct channel *ch)
 {
                 outb_p(ch->txwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxe_memoff(struct channel *ch)
+static void pcxe_memoff(struct channel *ch)
 {
         outb_p(0, (int)ch->board->port);
         outb_p(0, (int)ch->board->port + 1);
@@ -348,44 +338,44 @@ static inline void pcxe_memoff(struct channel *ch)
 
 /* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
 
-static inline void pcxi_memwinon(struct board_info *b, unsigned int win)
+static void pcxi_memwinon(struct board_info *b, unsigned int win)
 {
-               outb_p(inb((int)b->port) | FEPMEM, (int)b->port);
+               outb_p(inb(b->port) | FEPMEM, b->port);
 }
 
-static inline void pcxi_memwinoff(struct board_info *b, unsigned int win)
+static void pcxi_memwinoff(struct board_info *b, unsigned int win)
 {
-        outb_p(inb((int)b->port) & ~FEPMEM, (int)b->port);
+        outb_p(inb(b->port) & ~FEPMEM, b->port);
 }
 
-static inline void pcxi_globalwinon(struct channel *ch)
+static void pcxi_globalwinon(struct channel *ch)
 {
-        outb_p(FEPMEM, (int)ch->board->port);
+        outb_p(FEPMEM, ch->board->port);
 }
 
-static inline void pcxi_rxwinon(struct channel *ch)
+static void pcxi_rxwinon(struct channel *ch)
 {
-                outb_p(FEPMEM, (int)ch->board->port);
+                outb_p(FEPMEM, ch->board->port);
 }
 
-static inline void pcxi_txwinon(struct channel *ch)
+static void pcxi_txwinon(struct channel *ch)
 {
-                outb_p(FEPMEM, (int)ch->board->port);
+                outb_p(FEPMEM, ch->board->port);
 }
 
-static inline void pcxi_memoff(struct channel *ch)
+static void pcxi_memoff(struct channel *ch)
 {
-        outb_p(0, (int)ch->board->port);
+        outb_p(0, ch->board->port);
 }
 
-static inline void pcxi_assertgwinon(struct channel *ch)
+static void pcxi_assertgwinon(struct channel *ch)
 {
-        epcaassert(inb((int)ch->board->port) & FEPMEM, "Global memory off");
+        epcaassert(inb(ch->board->port) & FEPMEM, "Global memory off");
 }
 
-static inline void pcxi_assertmemoff(struct channel *ch)
+static void pcxi_assertmemoff(struct channel *ch)
 {
-        epcaassert(!(inb((int)ch->board->port) & FEPMEM), "Memory on");
+        epcaassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
 }
 
 
@@ -398,185 +388,143 @@ static inline void pcxi_assertmemoff(struct channel *ch)
         may or may not do anything.
 ---------------------------------------------------------------------------*/
 
-static inline void dummy_memwinon(struct board_info *b, unsigned int win)
+static void dummy_memwinon(struct board_info *b, unsigned int win)
 {
 }
 
-static inline void dummy_memwinoff(struct board_info *b, unsigned int win)
+static void dummy_memwinoff(struct board_info *b, unsigned int win)
 {
 }
 
-static inline void dummy_globalwinon(struct channel *ch)
+static void dummy_globalwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_rxwinon(struct channel *ch)
+static void dummy_rxwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_txwinon(struct channel *ch)
+static void dummy_txwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_memoff(struct channel *ch)
+static void dummy_memoff(struct channel *ch)
 {
 }
 
-static inline void dummy_assertgwinon(struct channel *ch)
+static void dummy_assertgwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_assertmemoff(struct channel *ch)
+static void dummy_assertmemoff(struct channel *ch)
 {
 }
 
 /* ----------------- Begin verifyChannel function ----------------------- */
-static inline struct channel *verifyChannel(register struct tty_struct *tty)
+static struct channel *verifyChannel(struct tty_struct *tty)
 { /* Begin verifyChannel */
-
         /* --------------------------------------------------------------------
                 This routine basically provides a sanity check.  It insures that
                 the channel returned is within the proper range of addresses as
                 well as properly initialized.  If some bogus info gets passed in
                 through tty->driver_data this should catch it.
-        --------------------------------------------------------------------- */
-
-        if (tty) 
-        { /* Begin if tty */
-
-                register struct channel *ch = (struct channel *)tty->driver_data;
-
-                if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs])) 
-                {
+                --------------------------------------------------------------------- */
+        if (tty) {
+                struct channel *ch = (struct channel *)tty->driver_data;
+                if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs])) {
                         if (ch->magic == EPCA_MAGIC)
                                 return ch;
                 }
-
-        } /* End if tty */
-
-        /* Else return a NULL for invalid */
+        }
         return NULL;
 
 } /* End verifyChannel */
 
 /* ------------------ Begin pc_sched_event ------------------------- */
 
-static inline void pc_sched_event(struct channel *ch, int event)
-{ /* Begin pc_sched_event */
-
-
+static void pc_sched_event(struct channel *ch, int event)
+{
         /* ----------------------------------------------------------------------
                 We call this to schedule interrupt processing on some event.  The 
                 kernel sees our request and calls the related routine in OUR driver.
         -------------------------------------------------------------------------*/
-
         ch->event |= 1 << event;
         schedule_work(&ch->tqueue);
-
-
 } /* End pc_sched_event */
 
 /* ------------------ Begin epca_error ------------------------- */
 
 static void epca_error(int line, char *msg)
-{ /* Begin epca_error */
-
+{
         printk(KERN_ERR "epca_error (Digi): line = %d %s\n",line,msg);
-        return;
-
-} /* End epca_error */
+}
 
 /* ------------------ Begin pc_close ------------------------- */
 static void pc_close(struct tty_struct * tty, struct file * filp)
-{ /* Begin pc_close */
-
+{
         struct channel *ch;
         unsigned long flags;
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if ch != NULL */
-
-                save_flags(flags);
-                cli();
-
-                if (tty_hung_up_p(filp)) 
-                {
-                        restore_flags(flags);
+        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if ch != NULL */
+                spin_lock_irqsave(&epca_lock, flags);
+                if (tty_hung_up_p(filp)) {
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         return;
                 }
-
                 /* Check to see if the channel is open more than once */
-                if (ch->count-- > 1) 
-                { /* Begin channel is open more than once */
-
+                if (ch->count-- > 1)  {
+                        /* Begin channel is open more than once */
                         /* -------------------------------------------------------------
                                 Return without doing anything.  Someone might still be using
                                 the channel.
                         ---------------------------------------------------------------- */
-
-                        restore_flags(flags);
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         return;
                 } /* End channel is open more than once */
 
                 /* Port open only once go ahead with shutdown & reset */
-
-                if (ch->count < 0) 
-                {
-                        ch->count = 0;
-                }
+                if (ch->count < 0)
+                        BUG();
 
                 /* ---------------------------------------------------------------
                         Let the rest of the driver know the channel is being closed.
                         This becomes important if an open is attempted before close 
                         is finished.
                 ------------------------------------------------------------------ */
-
                 ch->asyncflags |= ASYNC_CLOSING;
-        
                 tty->closing = 1;
 
-                if (ch->asyncflags & ASYNC_INITIALIZED) 
-                {
+                spin_unlock_irqrestore(&epca_lock, flags);
+
+                if (ch->asyncflags & ASYNC_INITIALIZED)  {
                         /* Setup an event to indicate when the transmit buffer empties */
                         setup_empty_event(tty, ch);             
                         tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
                 }
-        
                 if (tty->driver->flush_buffer)
                         tty->driver->flush_buffer(tty);
 
                 tty_ldisc_flush(tty);
                 shutdown(ch);
+
+                spin_lock_irqsave(&epca_lock, flags);
                 tty->closing = 0;
                 ch->event = 0;
                 ch->tty = NULL;
+                spin_unlock_irqrestore(&epca_lock, flags);
 
-                if (ch->blocked_open) 
-                { /* Begin if blocked_open */
-
+                if (ch->blocked_open)  { /* Begin if blocked_open */
                         if (ch->close_delay) 
-                        {
                                 msleep_interruptible(jiffies_to_msecs(ch->close_delay));
-                        }
-
                         wake_up_interruptible(&ch->open_wait);
-
                 } /* End if blocked_open */
-
                 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED | 
                                       ASYNC_CLOSING);
                 wake_up_interruptible(&ch->close_wait);
-
-
-                restore_flags(flags);
-
         } /* End if ch != NULL */
-
 } /* End pc_close */ 
 
 /* ------------------ Begin shutdown  ------------------------- */
@@ -586,15 +534,14 @@ static void shutdown(struct channel *ch)
 
         unsigned long flags;
         struct tty_struct *tty;
-        volatile struct board_chan *bc;
+        struct board_chan *bc;
 
         if (!(ch->asyncflags & ASYNC_INITIALIZED)) 
                 return;
 
-        save_flags(flags);
-        cli();
-        globalwinon(ch);
+        spin_lock_irqsave(&epca_lock, flags);
 
+        globalwinon(ch);
         bc = ch->brdchan;
 
         /* ------------------------------------------------------------------
@@ -604,20 +551,17 @@ static void shutdown(struct channel *ch)
         --------------------------------------------------------------------- */ 
 
         if (bc)
-                bc->idata = 0;
-
+                writeb(0, &bc->idata);
         tty = ch->tty;
 
         /* ----------------------------------------------------------------
            If we're a modem control device and HUPCL is on, drop RTS & DTR.
         ------------------------------------------------------------------ */
 
-        if (tty->termios->c_cflag & HUPCL) 
-        {
+        if (tty->termios->c_cflag & HUPCL)  {
                 ch->omodem &= ~(ch->m_rts | ch->m_dtr);
                 fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
         }
-
         memoff(ch);
 
         /* ------------------------------------------------------------------
@@ -628,7 +572,7 @@ static void shutdown(struct channel *ch)
         /* Prevent future Digi programmed interrupts from coming active */
 
         ch->asyncflags &= ~ASYNC_INITIALIZED;
-        restore_flags(flags);
+        spin_unlock_irqrestore(&epca_lock, flags);
 
 } /* End shutdown */
 
@@ -636,7 +580,6 @@ static void shutdown(struct channel *ch)
 
 static void pc_hangup(struct tty_struct *tty)
 { /* Begin pc_hangup */
-
         struct channel *ch;
         
         /* ---------------------------------------------------------
@@ -644,25 +587,21 @@ static void pc_hangup(struct tty_struct *tty)
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
 
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if ch != NULL */
-
+        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if ch != NULL */
                 unsigned long flags;
 
-                save_flags(flags);
-                cli();
                 if (tty->driver->flush_buffer)
                         tty->driver->flush_buffer(tty);
                 tty_ldisc_flush(tty);
                 shutdown(ch);
 
+                spin_lock_irqsave(&epca_lock, flags);
                 ch->tty   = NULL;
                 ch->event = 0;
                 ch->count = 0;
-                restore_flags(flags);
                 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED);
+                spin_unlock_irqrestore(&epca_lock, flags);
                 wake_up_interruptible(&ch->open_wait);
-
         } /* End if ch != NULL */
 
 } /* End pc_hangup */
@@ -672,18 +611,14 @@ static void pc_hangup(struct tty_struct *tty)
 static int pc_write(struct tty_struct * tty,
                     const unsigned char *buf, int bytesAvailable)
 { /* Begin pc_write */
-
-        register unsigned int head, tail;
-        register int dataLen;
-        register int size;
-        register int amountCopied;
-
-
+        unsigned int head, tail;
+        int dataLen;
+        int size;
+        int amountCopied;
         struct channel *ch;
         unsigned long flags;
         int remain;
-        volatile struct board_chan *bc;
-
+        struct board_chan *bc;
 
         /* ----------------------------------------------------------------
                 pc_write is primarily called directly by the kernel routine
@@ -706,24 +641,20 @@ static int pc_write(struct tty_struct * tty,
 
         bc   = ch->brdchan;
         size = ch->txbufsize;
-
         amountCopied = 0;
-        save_flags(flags);
-        cli();
 
+        spin_lock_irqsave(&epca_lock, flags);
         globalwinon(ch);
 
-        head = bc->tin & (size - 1);
-        tail = bc->tout;
+        head = readw(&bc->tin) & (size - 1);
+        tail = readw(&bc->tout);
 
-        if (tail != bc->tout)
-                tail = bc->tout;
+        if (tail != readw(&bc->tout))
+                tail = readw(&bc->tout);
         tail &= (size - 1);
 
         /*      If head >= tail, head has not wrapped around. */ 
-        if (head >= tail) 
-        { /* Begin head has not wrapped */
-
+        if (head >= tail)  { /* Begin head has not wrapped */
                 /* ---------------------------------------------------------------
                         remain (much like dataLen above) represents the total amount of
                         space available on the card for data.  Here dataLen represents
@@ -731,26 +662,19 @@ static int pc_write(struct tty_struct * tty,
                         buffer.  This is important because a memcpy cannot be told to
                         automatically wrap around when it hits the buffer end.
                 ------------------------------------------------------------------ */ 
-
                 dataLen = size - head;
                 remain = size - (head - tail) - 1;
-
-        } /* End head has not wrapped */
-        else 
-        { /* Begin head has wrapped around */
+        } else { /* Begin head has wrapped around */
 
                 remain = tail - head - 1;
                 dataLen = remain;
 
         } /* End head has wrapped around */
-
         /* -------------------------------------------------------------------
                         Check the space on the card.  If we have more data than 
                         space; reduce the amount of data to fit the space.
         ---------------------------------------------------------------------- */
-
         bytesAvailable = min(remain, bytesAvailable);
-
         txwinon(ch);
         while (bytesAvailable > 0) 
         { /* Begin while there is data to copy onto card */
@@ -767,26 +691,21 @@ static int pc_write(struct tty_struct * tty,
                 amountCopied += dataLen;
                 bytesAvailable -= dataLen;
 
-                if (head >= size) 
-                {
+                if (head >= size) {
                         head = 0;
                         dataLen = tail;
                 }
-
         } /* End while there is data to copy onto card */
-
         ch->statusflags |= TXBUSY;
         globalwinon(ch);
-        bc->tin = head;
+        writew(head, &bc->tin);
 
-        if ((ch->statusflags & LOWWAIT) == 0) 
-        {
+        if ((ch->statusflags & LOWWAIT) == 0)  {
                 ch->statusflags |= LOWWAIT;
-                bc->ilow = 1;
+                writeb(1, &bc->ilow);
         }
         memoff(ch);
-        restore_flags(flags);
-
+        spin_unlock_irqrestore(&epca_lock, flags);
         return(amountCopied);
 
 } /* End pc_write */
@@ -795,11 +714,7 @@ static int pc_write(struct tty_struct * tty,
 
 static void pc_put_char(struct tty_struct *tty, unsigned char c)
 { /* Begin pc_put_char */
-
-   
         pc_write(tty, &c, 1);
-        return;
-
 } /* End pc_put_char */
 
 /* ------------------ Begin pc_write_room  ------------------------- */
@@ -811,7 +726,7 @@ static int pc_write_room(struct tty_struct *tty)
         struct channel *ch;
         unsigned long flags;
         unsigned int head, tail;
-        volatile struct board_chan *bc;
+        struct board_chan *bc;
 
         remain = 0;
 
@@ -820,33 +735,29 @@ static int pc_write_room(struct tty_struct *tty)
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
 
-        if ((ch = verifyChannel(tty)) != NULL) 
-        {
-                save_flags(flags);
-                cli();
+        if ((ch = verifyChannel(tty)) != NULL)  {
+                spin_lock_irqsave(&epca_lock, flags);
                 globalwinon(ch);
 
                 bc   = ch->brdchan;
-                head = bc->tin & (ch->txbufsize - 1);
-                tail = bc->tout;
+                head = readw(&bc->tin) & (ch->txbufsize - 1);
+                tail = readw(&bc->tout);
 
-                if (tail != bc->tout)
-                        tail = bc->tout;
+                if (tail != readw(&bc->tout))
+                        tail = readw(&bc->tout);
                 /* Wrap tail if necessary */
                 tail &= (ch->txbufsize - 1);
 
                 if ((remain = tail - head - 1) < 0 )
                         remain += ch->txbufsize;
 
-                if (remain && (ch->statusflags & LOWWAIT) == 0) 
-                {
+                if (remain && (ch->statusflags & LOWWAIT) == 0) {
                         ch->statusflags |= LOWWAIT;
-                        bc->ilow = 1;
+                        writeb(1, &bc->ilow);
                 }
                 memoff(ch);
-                restore_flags(flags);
+                spin_unlock_irqrestore(&epca_lock, flags);
         }
-
         /* Return how much room is left on card */
         return remain;
 
@@ -862,8 +773,7 @@ static int pc_chars_in_buffer(struct tty_struct *tty)
         int remain;
         unsigned long flags;
         struct channel *ch;
-        volatile struct board_chan *bc;
-
+        struct board_chan *bc;
 
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
@@ -873,34 +783,27 @@ static int pc_chars_in_buffer(struct tty_struct *tty)
         if ((ch = verifyChannel(tty)) == NULL)
                 return(0);
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&epca_lock, flags);
         globalwinon(ch);
 
         bc = ch->brdchan;
-        tail = bc->tout;
-        head = bc->tin;
-        ctail = ch->mailbox->cout;
+        tail = readw(&bc->tout);
+        head = readw(&bc->tin);
+        ctail = readw(&ch->mailbox->cout);
 
-        if (tail == head && ch->mailbox->cin == ctail && bc->tbusy == 0)
+        if (tail == head && readw(&ch->mailbox->cin) == ctail && readb(&bc->tbusy) == 0)
                 chars = 0;
-        else 
-        { /* Begin if some space on the card has been used */
-
-                head = bc->tin & (ch->txbufsize - 1);
+        else  { /* Begin if some space on the card has been used */
+                head = readw(&bc->tin) & (ch->txbufsize - 1);
                 tail &= (ch->txbufsize - 1);
-
                 /*  --------------------------------------------------------------
                         The logic here is basically opposite of the above pc_write_room
                         here we are finding the amount of bytes in the buffer filled.
                         Not the amount of bytes empty.
                 ------------------------------------------------------------------- */
-
                 if ((remain = tail - head - 1) < 0 )
                         remain += ch->txbufsize;
-
                 chars = (int)(ch->txbufsize - remain);
-
                 /* -------------------------------------------------------------  
                         Make it possible to wakeup anything waiting for output
                         in tty_ioctl.c, etc.
@@ -908,15 +811,12 @@ static int pc_chars_in_buffer(struct tty_struct *tty)
                         If not already set.  Setup an event to indicate when the
                         transmit buffer empties 
                 ----------------------------------------------------------------- */
-
                 if (!(ch->statusflags & EMPTYWAIT))
                         setup_empty_event(tty,ch);
 
         } /* End if some space on the card has been used */
-
         memoff(ch);
-        restore_flags(flags);
-
+        spin_unlock_irqrestore(&epca_lock, flags);
         /* Return number of characters residing on card. */
         return(chars);
 
@@ -930,67 +830,46 @@ static void pc_flush_buffer(struct tty_struct *tty)
         unsigned int tail;
         unsigned long flags;
         struct channel *ch;
-        volatile struct board_chan *bc;
-
-
+        struct board_chan *bc;
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
         if ((ch = verifyChannel(tty)) == NULL)
                 return;
 
-        save_flags(flags);
-        cli();
-
+        spin_lock_irqsave(&epca_lock, flags);
         globalwinon(ch);
-
         bc   = ch->brdchan;
-        tail = bc->tout;
-
+        tail = readw(&bc->tout);
         /* Have FEP move tout pointer; effectively flushing transmit buffer */
-
         fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
-
         memoff(ch);
-        restore_flags(flags);
-
+        spin_unlock_irqrestore(&epca_lock, flags);
         wake_up_interruptible(&tty->write_wait);
         tty_wakeup(tty);
-
 } /* End pc_flush_buffer */
 
 /* ------------------ Begin pc_flush_chars  ---------------------- */
 
 static void pc_flush_chars(struct tty_struct *tty)
 { /* Begin pc_flush_chars */
-
         struct channel * ch;
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        {
+        if ((ch = verifyChannel(tty)) != NULL) {
                 unsigned long flags;
-
-                save_flags(flags);
-                cli();
-
+                spin_lock_irqsave(&epca_lock, flags);
                 /* ----------------------------------------------------------------
                         If not already set and the transmitter is busy setup an event
                         to indicate when the transmit empties.
                 ------------------------------------------------------------------- */
-
                 if ((ch->statusflags & TXBUSY) && !(ch->statusflags & EMPTYWAIT))
                         setup_empty_event(tty,ch);
-
-                restore_flags(flags);
+                spin_unlock_irqrestore(&epca_lock, flags);
         }
-
 } /* End pc_flush_chars */
 
 /* ------------------ Begin block_til_ready  ---------------------- */
@@ -998,14 +877,11 @@ static void pc_flush_chars(struct tty_struct *tty)
 static int block_til_ready(struct tty_struct *tty, 
                            struct file *filp, struct channel *ch)
 { /* Begin block_til_ready */
-
         DECLARE_WAITQUEUE(wait,current);
         int     retval, do_clocal = 0;
         unsigned long flags;
 
-
-        if (tty_hung_up_p(filp))
-        {
+        if (tty_hung_up_p(filp)) {
                 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
                         retval = -EAGAIN;
                 else
@@ -1017,8 +893,7 @@ static int block_til_ready(struct tty_struct *tty,
                 If the device is in the middle of being closed, then block
                 until it's done, and then try again.
         -------------------------------------------------------------------- */
-        if (ch->asyncflags & ASYNC_CLOSING) 
-        {
+        if (ch->asyncflags & ASYNC_CLOSING) {
                 interruptible_sleep_on(&ch->close_wait);
 
                 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
@@ -1027,43 +902,29 @@ static int block_til_ready(struct tty_struct *tty,
                         return -ERESTARTSYS;
         }
 
-        if (filp->f_flags & O_NONBLOCK) 
-        {
+        if (filp->f_flags & O_NONBLOCK)  {
                 /* ----------------------------------------------------------------- 
                  If non-blocking mode is set, then make the check up front
                  and then exit.
                 -------------------------------------------------------------------- */
-
                 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
-
                 return 0;
         }
-
-
         if (tty->termios->c_cflag & CLOCAL)
                 do_clocal = 1;
-        
-   /* Block waiting for the carrier detect and the line to become free */
+        /* Block waiting for the carrier detect and the line to become free */
         
         retval = 0;
         add_wait_queue(&ch->open_wait, &wait);
-        save_flags(flags);
-        cli();
-
 
+        spin_lock_irqsave(&epca_lock, flags);
         /* We dec count so that pc_close will know when to free things */
         if (!tty_hung_up_p(filp))
                 ch->count--;
-
-        restore_flags(flags);
-
         ch->blocked_open++;
-
         while(1) 
         { /* Begin forever while  */
-
                 set_current_state(TASK_INTERRUPTIBLE);
-
                 if (tty_hung_up_p(filp) ||
                     !(ch->asyncflags & ASYNC_INITIALIZED)) 
                 {
@@ -1073,17 +934,14 @@ static int block_til_ready(struct tty_struct *tty,
                                 retval = -ERESTARTSYS;  
                         break;
                 }
-
                 if (!(ch->asyncflags & ASYNC_CLOSING) && 
                           (do_clocal || (ch->imodem & ch->dcd)))
                         break;
-
-                if (signal_pending(current)) 
-                {
+                if (signal_pending(current)) {
                         retval = -ERESTARTSYS;
                         break;
                 }
-
+                spin_unlock_irqrestore(&epca_lock, flags);
                 /* ---------------------------------------------------------------
                         Allow someone else to be scheduled.  We will occasionally go
                         through this loop until one of the above conditions change.
@@ -1091,25 +949,23 @@ static int block_til_ready(struct tty_struct *tty,
                         prevent this loop from hogging the cpu.
                 ------------------------------------------------------------------ */
                 schedule();
+                spin_lock_irqsave(&epca_lock, flags);
 
         } /* End forever while  */
 
         current->state = TASK_RUNNING;
         remove_wait_queue(&ch->open_wait, &wait);
-        cli();
         if (!tty_hung_up_p(filp))
                 ch->count++;
-        restore_flags(flags);
-
         ch->blocked_open--;
 
+        spin_unlock_irqrestore(&epca_lock, flags);
+
         if (retval)
                 return retval;
 
         ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
-
         return 0;
-
 } /* End block_til_ready */     
 
 /* ------------------ Begin pc_open  ---------------------- */
@@ -1120,17 +976,12 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
         struct channel *ch;
         unsigned long flags;
         int line, retval, boardnum;
-        volatile struct board_chan *bc;
-        volatile unsigned int head;
+        struct board_chan *bc;
+        unsigned int head;
 
         line = tty->index;
-        if (line < 0 || line >= nbdevs) 
-        {
-                printk(KERN_ERR "<Error> - pc_open : line out of range in pc_open\n");
-                tty->driver_data = NULL;
-                return(-ENODEV);
-        }
-
+        if (line < 0 || line >= nbdevs)
+                return -ENODEV;
 
         ch = &digi_channels[line];
         boardnum = ch->boardnum;
@@ -1143,66 +994,49 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
                 goes here.
         ---------------------------------------------------------------------- */
 
-        if (invalid_lilo_config)
-        {
+        if (invalid_lilo_config) {
                 if (setup_error_code & INVALID_BOARD_TYPE)
-                        printk(KERN_ERR "<Error> - pc_open: Invalid board type specified in LILO command\n");
-
+                        printk(KERN_ERR "epca: pc_open: Invalid board type specified in kernel options.\n");
                 if (setup_error_code & INVALID_NUM_PORTS)
-                        printk(KERN_ERR "<Error> - pc_open: Invalid number of ports specified in LILO command\n");
-
+                        printk(KERN_ERR "epca: pc_open: Invalid number of ports specified in kernel options.\n");
                 if (setup_error_code & INVALID_MEM_BASE)
-                        printk(KERN_ERR "<Error> - pc_open: Invalid board memory address specified in LILO command\n");
-
+                        printk(KERN_ERR "epca: pc_open: Invalid board memory address specified in kernel options.\n");
                 if (setup_error_code & INVALID_PORT_BASE)
-                        printk(KERN_ERR "<Error> - pc_open: Invalid board port address specified in LILO command\n");
-
+                        printk(KERN_ERR "epca; pc_open: Invalid board port address specified in kernel options.\n");
                 if (setup_error_code & INVALID_BOARD_STATUS)
-                        printk(KERN_ERR "<Error> - pc_open: Invalid board status specified in LILO command\n");
-
+                        printk(KERN_ERR "epca: pc_open: Invalid board status specified in kernel options.\n");
                 if (setup_error_code & INVALID_ALTPIN)
-                        printk(KERN_ERR "<Error> - pc_open: Invalid board altpin specified in LILO command\n");
-
+                        printk(KERN_ERR "epca: pc_open: Invalid board altpin specified in kernel options;\n");
                 tty->driver_data = NULL;   /* Mark this device as 'down' */
-                return(-ENODEV);
+                return -ENODEV;
         }
-
-        if ((boardnum >= num_cards) || (boards[boardnum].status == DISABLED)) 
-        {
+        if (boardnum >= num_cards || boards[boardnum].status == DISABLED)  {
                 tty->driver_data = NULL;   /* Mark this device as 'down' */
                 return(-ENODEV);
         }
         
-        if (( bc = ch->brdchan) == 0) 
-        {
+        if ((bc = ch->brdchan) == 0) {
                 tty->driver_data = NULL;
-                return(-ENODEV);
+                return -ENODEV;
         }
 
+        spin_lock_irqsave(&epca_lock, flags);
         /* ------------------------------------------------------------------
                 Every time a channel is opened, increment a counter.  This is 
                 necessary because we do not wish to flush and shutdown the channel
                 until the last app holding the channel open, closes it.         
         --------------------------------------------------------------------- */
-
         ch->count++;
-
         /* ----------------------------------------------------------------
                 Set a kernel structures pointer to our local channel 
                 structure.  This way we can get to it when passed only
                 a tty struct.
         ------------------------------------------------------------------ */
-
         tty->driver_data = ch;
-        
         /* ----------------------------------------------------------------
                 If this is the first time the channel has been opened, initialize
                 the tty->termios struct otherwise let pc_close handle it.
         -------------------------------------------------------------------- */
-
-        save_flags(flags);
-        cli();
-
         globalwinon(ch);
         ch->statusflags = 0;
 
@@ -1213,8 +1047,8 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
            Set receive head and tail ptrs to each other.  This indicates
            no data available to read.
         ----------------------------------------------------------------- */
-        head = bc->rin;
-        bc->rout = head;
+        head = readw(&bc->rin);
+        writew(head, &bc->rout);
 
         /* Set the channels associated tty structure */
         ch->tty = tty;
@@ -1224,122 +1058,74 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
                 issues, etc.... It effect both control flags and input flags.
         -------------------------------------------------------------------- */
         epcaparam(tty,ch);
-
         ch->asyncflags |= ASYNC_INITIALIZED;
         memoff(ch);
-
-        restore_flags(flags);
+        spin_unlock_irqrestore(&epca_lock, flags);
 
         retval = block_til_ready(tty, filp, ch);
         if (retval)
-        {
                 return retval;
-        }
-
         /* -------------------------------------------------------------
                 Set this again in case a hangup set it to zero while this 
                 open() was waiting for the line...
         --------------------------------------------------------------- */
+        spin_lock_irqsave(&epca_lock, flags);
         ch->tty = tty;
-
-        save_flags(flags);
-        cli();
         globalwinon(ch);
-
         /* Enable Digi Data events */
-        bc->idata = 1;
-
+        writeb(1, &bc->idata);
         memoff(ch);
-        restore_flags(flags);
-
+        spin_unlock_irqrestore(&epca_lock, flags);
         return 0;
-
 } /* End pc_open */
 
-#ifdef MODULE
 static int __init epca_module_init(void)
 { /* Begin init_module */
-
-        unsigned long   flags;
-
-        save_flags(flags);
-        cli();
-
-        pc_init();
-
-        restore_flags(flags);
-
-        return(0);
+        return pc_init();
 }
 
 module_init(epca_module_init);
-#endif
 
-#ifdef ENABLE_PCI
 static struct pci_driver epca_driver;
-#endif
-
-#ifdef MODULE
-/* -------------------- Begin cleanup_module  ---------------------- */
 
 static void __exit epca_module_exit(void)
 {
-
         int               count, crd;
         struct board_info *bd;
         struct channel    *ch;
-        unsigned long     flags;
 
         del_timer_sync(&epca_timer);
 
-        save_flags(flags);
-        cli();
-
         if ((tty_unregister_driver(pc_driver)) ||  
             (tty_unregister_driver(pc_info)))
         {
-                printk(KERN_WARNING "<Error> - DIGI : cleanup_module failed to un-register tty driver\n");
-                restore_flags(flags);
+                printk(KERN_WARNING "epca: cleanup_module failed to un-register tty driver\n");
                 return;
         }
         put_tty_driver(pc_driver);
         put_tty_driver(pc_info);
 
-        for (crd = 0; crd < num_cards; crd++) 
-        { /* Begin for each card */
-
+        for (crd = 0; crd < num_cards; crd++)  { /* Begin for each card */
                 bd = &boards[crd];
-
                 if (!bd)
                 { /* Begin sanity check */
                         printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
                         return;
                 } /* End sanity check */
-
-                ch = card_ptr[crd]; 
-
+                ch = card_ptr[crd];
                 for (count = 0; count < bd->numports; count++, ch++) 
                 { /* Begin for each port */
-
-                        if (ch) 
-                        {
+                        if (ch) {
                                 if (ch->tty)
                                         tty_hangup(ch->tty);
                                 kfree(ch->tmp_buf);
                         }
-
                 } /* End for each port */
         } /* End for each card */
-
-#ifdef ENABLE_PCI
         pci_unregister_driver (&epca_driver);
-#endif
-
-        restore_flags(flags);
-
 }
+
 module_exit(epca_module_exit);
-#endif /* MODULE */
 
 static struct tty_operations pc_ops = {
         .open = pc_open,
@@ -1371,34 +1157,15 @@ static struct tty_operations info_ops = {
 
 /* ------------------ Begin pc_init  ---------------------- */
 
-int __init pc_init(void)
+static int __init pc_init(void)
 { /* Begin pc_init */
-
-        /* ----------------------------------------------------------------
-                pc_init is called by the operating system during boot up prior to
-                any open calls being made.  In the older versions of Linux (Prior
-                to 2.0.0) an entry is made into tty_io.c.  A pointer to the last
-                memory location (from kernel space) used (kmem_start) is passed
-                to pc_init.  It is pc_inits responsibility to modify this value 
-                for any memory that the Digi driver might need and then return
-                this value to the operating system.  For example if the driver
-                wishes to allocate 1K of kernel memory, pc_init would return 
-                (kmem_start + 1024).  This memory (Between kmem_start and kmem_start
-                + 1024) would then be available for use exclusively by the driver.  
-                In this case our driver does not allocate any of this kernel 
-                memory.
-        ------------------------------------------------------------------*/
-
-        ulong flags;
         int crd;
         struct board_info *bd;
         unsigned char board_id = 0;
 
-#ifdef ENABLE_PCI
         int pci_boards_found, pci_count;
 
         pci_count = 0;
-#endif /* ENABLE_PCI */
 
         pc_driver = alloc_tty_driver(MAX_ALLOC);
         if (!pc_driver)
@@ -1416,8 +1183,7 @@ int __init pc_init(void)
                 Note : If LILO has ran epca_setup then epca_setup will handle defining
                 num_cards as well as copying the data into the board structure.
         -------------------------------------------------------------------------- */
-        if (!liloconfig)
-        { /* Begin driver has been configured via. epcaconfig */
+        if (!liloconfig) { /* Begin driver has been configured via. epcaconfig */
 
                 nbdevs = NBDEVS;
                 num_cards = NUMCARDS;
@@ -1440,8 +1206,6 @@ int __init pc_init(void)
 
         printk(KERN_INFO "DIGI epca driver version %s loaded.\n",VERSION);
 
-#ifdef ENABLE_PCI
-
         /* ------------------------------------------------------------------
                 NOTE : This code assumes that the number of ports found in 
                        the boards array is correct.  This could be wrong if
@@ -1467,8 +1231,6 @@ int __init pc_init(void)
                 pci_boards_found += init_PCI();
         num_cards += pci_boards_found;
 
-#endif /* ENABLE_PCI */
-
         pc_driver->owner = THIS_MODULE;
         pc_driver->name = "ttyD"; 
         pc_driver->devfs_name = "tts/D";
@@ -1499,9 +1261,6 @@ int __init pc_init(void)
         tty_set_operations(pc_info, &info_ops);
 
 
-        save_flags(flags);
-        cli();
-
         for (crd = 0; crd < num_cards; crd++) 
         { /* Begin for each card */
 
@@ -1610,11 +1369,7 @@ int __init pc_init(void)
                                         if ((board_id & 0x30) == 0x30) 
                                                 bd->memory_seg = 0x8000;
 
-                                } /* End it is an XI card */
-                                else
-                                {
-                                        printk(KERN_ERR "<Error> - Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
-                                }
+                                } else printk(KERN_ERR "epca: Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
                         break;
 
                 } /* End switch on bd->type */
@@ -1634,9 +1389,6 @@ int __init pc_init(void)
         init_timer(&epca_timer);
         epca_timer.function = epcapoll;
         mod_timer(&epca_timer, jiffies + HZ/25);
-
-        restore_flags(flags);
-
         return 0;
 
 } /* End pc_init */
@@ -1647,10 +1399,10 @@ static void post_fep_init(unsigned int crd)
 { /* Begin post_fep_init */
 
         int i;
-        unchar *memaddr;
-        volatile struct global_data *gd;
+        unsigned char *memaddr;
+        struct global_data *gd;
         struct board_info *bd;
-        volatile struct board_chan *bc;
+        struct board_chan *bc;
         struct channel *ch; 
         int shrinkmem = 0, lowwater ; 
  
@@ -1669,9 +1421,7 @@ static void post_fep_init(unsigned int crd)
                 after DIGI_INIT has been called will return the proper values. 
         ------------------------------------------------------------------- */
 
-        if (bd->type >= PCIXEM) /* If the board in question is PCI */
-        { /* Begin get PCI number of ports */
-
+        if (bd->type >= PCIXEM) { /* Begin get PCI number of ports */
                 /* --------------------------------------------------------------------
                         Below we use XEMPORTS as a memory offset regardless of which PCI
                         card it is.  This is because all of the supported PCI cards have
@@ -1685,15 +1435,15 @@ static void post_fep_init(unsigned int crd)
                         (FYI - The id should be located at 0x1ac (And may use up to 4 bytes
                         if the box in question is a XEM or CX)).  
                 ------------------------------------------------------------------------ */ 
-
-                bd->numports = (unsigned short)*(unsigned char *)bus_to_virt((unsigned long)
-                                                       (bd->re_map_membase + XEMPORTS));
-
-                
+                /* PCI cards are already remapped at this point ISA are not */
+                bd->numports = readw(bd->re_map_membase + XEMPORTS);
                 epcaassert(bd->numports <= 64,"PCI returned a invalid number of ports");
                 nbdevs += (bd->numports);
-
-        } /* End get PCI number of ports */
+        } else {
+                /* Fix up the mappings for ISA/EISA etc */
+                /* FIXME: 64K - can we be smarter ? */
+                bd->re_map_membase = ioremap(bd->membase, 0x10000);
+        }
 
         if (crd != 0)
                 card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
@@ -1701,19 +1451,9 @@ static void post_fep_init(unsigned int crd)
                 card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
 
         ch = card_ptr[crd];
-
-
         epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
 
-        memaddr = (unchar *)bd->re_map_membase;
-
-        /* 
-           The below command is necessary because newer kernels (2.1.x and
-           up) do not have a 1:1 virtual to physical mapping.  The below
-           call adjust for that.
-        */
-
-        memaddr = (unsigned char *)bus_to_virt((unsigned long)memaddr);
+        memaddr = bd->re_map_membase;
 
         /* -----------------------------------------------------------------
                 The below assignment will set bc to point at the BEGINING of
@@ -1721,7 +1461,7 @@ static void post_fep_init(unsigned int crd)
                 8 and 64 of these structures.
         -------------------------------------------------------------------- */
 
-        bc = (volatile struct board_chan *)((ulong)memaddr + CHANSTRUCT);
+        bc = (struct board_chan *)(memaddr + CHANSTRUCT);
 
         /* -------------------------------------------------------------------
                 The below assignment will set gd to point at the BEGINING of
@@ -1730,20 +1470,18 @@ static void post_fep_init(unsigned int crd)
                 pointer begins at 0xd10.
         ---------------------------------------------------------------------- */
 
-        gd = (volatile struct global_data *)((ulong)memaddr + GLOBAL);
+        gd = (struct global_data *)(memaddr + GLOBAL);
 
         /* --------------------------------------------------------------------
                 XEPORTS (address 0xc22) points at the number of channels the
                 card supports. (For 64XE, XI, XEM, and XR use 0xc02)
         ----------------------------------------------------------------------- */
 
-        if (((bd->type == PCXEVE) | (bd->type == PCXE)) &&
-            (*(ushort *)((ulong)memaddr + XEPORTS) < 3))
+        if ((bd->type == PCXEVE || bd->type == PCXE) && (readw(memaddr + XEPORTS) < 3))
                 shrinkmem = 1;
         if (bd->type < PCIXEM)
                 if (!request_region((int)bd->port, 4, board_desc[bd->type]))
                         return;         
-
         memwinon(bd, 0);
 
         /*  --------------------------------------------------------------------
@@ -1753,17 +1491,16 @@ static void post_fep_init(unsigned int crd)
 
         /* For every port on the card do ..... */
 
-        for (i = 0; i < bd->numports; i++, ch++, bc++) 
-        { /* Begin for each port */
+        for (i = 0; i < bd->numports; i++, ch++, bc++)  { /* Begin for each port */
+                unsigned long flags;
 
                 ch->brdchan        = bc;
                 ch->mailbox        = gd; 
                 INIT_WORK(&ch->tqueue, do_softint, ch);
                 ch->board          = &boards[crd];
 
-                switch (bd->type)
-                { /* Begin switch bd->type */
-
+                spin_lock_irqsave(&epca_lock, flags);
+                switch (bd->type) {
                         /* ----------------------------------------------------------------
                                 Since some of the boards use different bitmaps for their
                                 control signals we cannot hard code these values and retain
@@ -1796,14 +1533,12 @@ static void post_fep_init(unsigned int crd)
         
                 } /* End switch bd->type */
 
-                if (boards[crd].altpin) 
-                {
+                if (boards[crd].altpin) {
                         ch->dsr = ch->m_dcd;
                         ch->dcd = ch->m_dsr;
                         ch->digiext.digi_flags |= DIGI_ALTPIN;
                 }
-                else 
-                { 
+                else {
                         ch->dcd = ch->m_dcd;
                         ch->dsr = ch->m_dsr;
                 }
@@ -1813,14 +1548,12 @@ static void post_fep_init(unsigned int crd)
                 ch->magic      = EPCA_MAGIC;
                 ch->tty        = NULL;
 
-                if (shrinkmem) 
-                {
+                if (shrinkmem) {
                         fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
                         shrinkmem = 0;
                 }
 
-                switch (bd->type)
-                { /* Begin switch bd->type */
+                switch (bd->type) {
 
                         case PCIXEM:
                         case PCIXRJ:
@@ -1878,13 +1611,13 @@ static void post_fep_init(unsigned int crd)
 
                 fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
 
-                bc->edelay = 100;
-                bc->idata = 1;
+                writew(100, &bc->edelay);
+                writeb(1, &bc->idata);
         
-                ch->startc  = bc->startc;
-                ch->stopc   = bc->stopc;
-                ch->startca = bc->startca;
-                ch->stopca  = bc->stopca;
+                ch->startc  = readb(&bc->startc);
+                ch->stopc   = readb(&bc->stopc);
+                ch->startca = readb(&bc->startca);
+                ch->stopca  = readb(&bc->stopca);
         
                 ch->fepcflag = 0;
                 ch->fepiflag = 0;
@@ -1899,27 +1632,23 @@ static void post_fep_init(unsigned int crd)
                 ch->blocked_open = 0;
                 init_waitqueue_head(&ch->open_wait);
                 init_waitqueue_head(&ch->close_wait);
+
+                spin_unlock_irqrestore(&epca_lock, flags);
+
                 ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
-                if (!(ch->tmp_buf))
-                {
+                if (!ch->tmp_buf) {
                         printk(KERN_ERR "POST FEP INIT : kmalloc failed for port 0x%x\n",i);
                         release_region((int)bd->port, 4);
                         while(i-- > 0)
                                 kfree((ch--)->tmp_buf);
                         return;
-                }
-                else 
+                } else
                         memset((void *)ch->tmp_buf,0,ch->txbufsize);
         } /* End for each port */
 
         printk(KERN_INFO 
                 "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n", 
                 VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
-        sprintf(mesg, 
-                "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n", 
-                VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
-        console_print(mesg);
-
         memwinoff(bd, 0);
 
 } /* End post_fep_init */
@@ -1943,9 +1672,6 @@ static void epcapoll(unsigned long ignored)
                 buffer empty) and acts on those events.
         ----------------------------------------------------------------------- */
         
-        save_flags(flags);
-        cli();
-
         for (crd = 0; crd < num_cards; crd++) 
         { /* Begin for each card */
 
@@ -1961,6 +1687,8 @@ static void epcapoll(unsigned long ignored)
                         some legacy boards.
                 ---------------------------------------------------------------- */
 
+                spin_lock_irqsave(&epca_lock, flags);
+
                 assertmemoff(ch);
 
                 globalwinon(ch);
@@ -1970,21 +1698,19 @@ static void epcapoll(unsigned long ignored)
                         the transmit or receive queue.
                 ------------------------------------------------------------------- */
 
-                head = ch->mailbox->ein;
-                tail = ch->mailbox->eout;
+                head = readw(&ch->mailbox->ein);
+                tail = readw(&ch->mailbox->eout);
                 
                 /* If head isn't equal to tail we have an event */
 
                 if (head != tail)
                         doevent(crd);
-
                 memoff(ch);
 
-        } /* End for each card */
+                spin_unlock_irqrestore(&epca_lock, flags);
 
+        } /* End for each card */
         mod_timer(&epca_timer, jiffies + (HZ / 25));
-
-        restore_flags(flags);
 } /* End epcapoll */
 
 /* --------------------- Begin doevent  ------------------------ */
@@ -1992,53 +1718,42 @@ static void epcapoll(unsigned long ignored)
 static void doevent(int crd)
 { /* Begin doevent */
 
-        volatile unchar *eventbuf;
+        void *eventbuf;
         struct channel *ch, *chan0;
         static struct tty_struct *tty;
-        volatile struct board_info *bd;
-        volatile struct board_chan *bc;
-        register volatile unsigned int tail, head;
-        register int event, channel;
-        register int mstat, lstat;
+        struct board_info *bd;
+        struct board_chan *bc;
+        unsigned int tail, head;
+        int event, channel;
+        int mstat, lstat;
 
         /* -------------------------------------------------------------------
                 This subroutine is called by epcapoll when an event is detected 
                 in the event queue.  This routine responds to those events.
         --------------------------------------------------------------------- */
-
         bd = &boards[crd];
 
         chan0 = card_ptr[crd];
         epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
-
         assertgwinon(chan0);
-
-        while ((tail = chan0->mailbox->eout) != (head = chan0->mailbox->ein)) 
+        while ((tail = readw(&chan0->mailbox->eout)) != (head = readw(&chan0->mailbox->ein)))
         { /* Begin while something in event queue */
-
                 assertgwinon(chan0);
-
-                eventbuf = (volatile unchar *)bus_to_virt((ulong)(bd->re_map_membase + tail + ISTART));
-
+                eventbuf = bd->re_map_membase + tail + ISTART;
                 /* Get the channel the event occurred on */
-                channel = eventbuf[0];
-
+                channel = readb(eventbuf);
                 /* Get the actual event code that occurred */
-                event = eventbuf[1];
-
+                event = readb(eventbuf + 1);
                 /*  ----------------------------------------------------------------
                         The two assignments below get the current modem status (mstat)
                         and the previous modem status (lstat).  These are useful becuase
                         an event could signal a change in modem signals itself.
                 ------------------------------------------------------------------- */
-
-                mstat = eventbuf[2];
-                lstat = eventbuf[3];
+                mstat = readb(eventbuf + 2);
+                lstat = readb(eventbuf + 3);
 
                 ch = chan0 + channel;
-
-                if ((unsigned)channel >= bd->numports || !ch) 
-                { 
+                if ((unsigned)channel >= bd->numports || !ch)  {
                         if (channel >= bd->numports)
                                 ch = chan0;
                         bc = ch->brdchan;
@@ -2048,97 +1763,53 @@ static void doevent(int crd)
                 if ((bc = ch->brdchan) == NULL)
                         goto next;
 
-                if (event & DATA_IND) 
-                { /* Begin DATA_IND */
-
+                if (event & DATA_IND)  { /* Begin DATA_IND */
                         receive_data(ch);
                         assertgwinon(ch);
-
                 } /* End DATA_IND */
                 /* else *//* Fix for DCD transition missed bug */
-                if (event & MODEMCHG_IND) 
-                { /* Begin MODEMCHG_IND */
-
+                if (event & MODEMCHG_IND)  { /* Begin MODEMCHG_IND */
                         /* A modem signal change has been indicated */
-
                         ch->imodem = mstat;
-
-                        if (ch->asyncflags & ASYNC_CHECK_CD) 
-                        {
+                        if (ch->asyncflags & ASYNC_CHECK_CD)  {
                                 if (mstat & ch->dcd)  /* We are now receiving dcd */
                                         wake_up_interruptible(&ch->open_wait);
                                 else
                                         pc_sched_event(ch, EPCA_EVENT_HANGUP); /* No dcd; hangup */
                         }
-
                 } /* End MODEMCHG_IND */
-
                 tty = ch->tty;
-                if (tty) 
-                { /* Begin if valid tty */
-
-                        if (event & BREAK_IND) 
-                        { /* Begin if BREAK_IND */
-
+                if (tty)  { /* Begin if valid tty */
+                        if (event & BREAK_IND)  { /* Begin if BREAK_IND */
                                 /* A break has been indicated */
-
                                 tty->flip.count++;
                                 *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-
                                 *tty->flip.char_buf_ptr++ = 0;
-
                                 tty_schedule_flip(tty); 
-
-                        } /* End if BREAK_IND */
-                        else
-                        if (event & LOWTX_IND) 
-                        { /* Begin LOWTX_IND */
-
+                        } else if (event & LOWTX_IND)  { /* Begin LOWTX_IND */
                                 if (ch->statusflags & LOWWAIT) 
                                 { /* Begin if LOWWAIT */
-
                                         ch->statusflags &= ~LOWWAIT;
                                         tty_wakeup(tty);
                                         wake_up_interruptible(&tty->write_wait);
-
                                 } /* End if LOWWAIT */
-
-                        } /* End LOWTX_IND */
-                        else
-                        if (event & EMPTYTX_IND) 
-                        { /* Begin EMPTYTX_IND */
-
+                        } else if (event & EMPTYTX_IND)  { /* Begin EMPTYTX_IND */
                                 /* This event is generated by setup_empty_event */
-
                                 ch->statusflags &= ~TXBUSY;
-                                if (ch->statusflags & EMPTYWAIT) 
-                                { /* Begin if EMPTYWAIT */
-
+                                if (ch->statusflags & EMPTYWAIT)  { /* Begin if EMPTYWAIT */
                                         ch->statusflags &= ~EMPTYWAIT;
                                         tty_wakeup(tty);
-
                                         wake_up_interruptible(&tty->write_wait);
-
                                 } /* End if EMPTYWAIT */
-
                         } /* End EMPTYTX_IND */
-
                 } /* End if valid tty */
-
-
         next:
                 globalwinon(ch);
-
-                if (!bc)
-                        printk(KERN_ERR "<Error> - bc == NULL in doevent!\n");
-                else 
-                        bc->idata = 1;
-
-                chan0->mailbox->eout = (tail + 4) & (IMAX - ISTART - 4);
+                BUG_ON(!bc);
+                writew(1, &bc->idata);
+                writew((tail + 4) & (IMAX - ISTART - 4), &chan0->mailbox->eout);
                 globalwinon(chan0);
-
         } /* End while something in event queue */
-
 } /* End doevent */
 
 /* --------------------- Begin fepcmd  ------------------------ */
@@ -2146,7 +1817,6 @@ static void doevent(int crd)
 static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
                    int byte2, int ncmds, int bytecmd)
 { /* Begin fepcmd */
-
         unchar *memaddr;
         unsigned int head, cmdTail, cmdStart, cmdMax;
         long count;
@@ -2155,93 +1825,57 @@ static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
         /* This is the routine in which commands may be passed to the card. */
 
         if (ch->board->status == DISABLED)
-        {
                 return;
-        }
-
         assertgwinon(ch);
-
         /* Remember head (As well as max) is just an offset not a base addr */
-        head = ch->mailbox->cin;
-
+        head = readw(&ch->mailbox->cin);
         /* cmdStart is a base address */
-        cmdStart = ch->mailbox->cstart;
-
+        cmdStart = readw(&ch->mailbox->cstart);
         /* ------------------------------------------------------------------
                 We do the addition below because we do not want a max pointer 
                 relative to cmdStart.  We want a max pointer that points at the 
                 physical end of the command queue.
         -------------------------------------------------------------------- */
-
-        cmdMax = (cmdStart + 4 + (ch->mailbox->cmax));
-
+        cmdMax = (cmdStart + 4 + readw(&ch->mailbox->cmax));
         memaddr = ch->board->re_map_membase;
 
-        /* 
-           The below command is necessary because newer kernels (2.1.x and
-           up) do not have a 1:1 virtual to physical mapping.  The below
-           call adjust for that.
-        */
-
-        memaddr = (unsigned char *)bus_to_virt((unsigned long)memaddr);
-
-        if (head >= (cmdMax - cmdStart) || (head & 03)) 
-        {
-                printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__, 
-              cmd, head);
-                printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__, 
-              cmdMax, cmdStart);
+        if (head >= (cmdMax - cmdStart) || (head & 03))  {
+                printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__,  cmd, head);
+                printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__,  cmdMax, cmdStart);
                 return;
         }
-
-        if (bytecmd) 
-        {
-                *(volatile unchar *)(memaddr + head + cmdStart + 0) = (unchar)cmd;
-
-                *(volatile unchar *)(memaddr + head + cmdStart + 1) = (unchar)ch->channelnum;
+        if (bytecmd)  {
+                writeb(cmd, memaddr + head + cmdStart + 0);
+                writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
                 /* Below word_or_byte is bits to set */
-                *(volatile unchar *)(memaddr + head + cmdStart + 2) = (unchar)word_or_byte;
+                writeb(word_or_byte,  memaddr + head + cmdStart + 2);
                 /* Below byte2 is bits to reset */
-                *(volatile unchar *)(memaddr + head + cmdStart + 3) = (unchar)byte2;
-
-        } 
-        else 
-        {
-                *(volatile unchar *)(memaddr + head + cmdStart + 0) = (unchar)cmd;
-                *(volatile unchar *)(memaddr + head + cmdStart + 1) = (unchar)ch->channelnum;
-                *(volatile ushort*)(memaddr + head + cmdStart + 2) = (ushort)word_or_byte;
+                writeb(byte2, memaddr + head + cmdStart + 3);
+        }  else {
+                writeb(cmd, memaddr + head + cmdStart + 0);
+                writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
+                writeb(word_or_byte,  memaddr + head + cmdStart + 2);
         }
-
         head = (head + 4) & (cmdMax - cmdStart - 4);
-        ch->mailbox->cin = head;
-
+        writew(head, &ch->mailbox->cin);
         count = FEPTIMEOUT;
 
-        for (;;) 
-        { /* Begin forever loop */
-
+        for (;;)  { /* Begin forever loop */
                 count--;
-                if (count == 0) 
-                {
+                if (count == 0)  {
                         printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
                         return;
                 }
-
-                head = ch->mailbox->cin;
-                cmdTail = ch->mailbox->cout;
-
+                head = readw(&ch->mailbox->cin);
+                cmdTail = readw(&ch->mailbox->cout);
                 n = (head - cmdTail) & (cmdMax - cmdStart - 4);
-
                 /* ----------------------------------------------------------
                         Basically this will break when the FEP acknowledges the 
                         command by incrementing cmdTail (Making it equal to head).
                 ------------------------------------------------------------- */
-
                 if (n <= ncmds * (sizeof(short) * 4))
                         break; /* Well nearly forever :-) */
-
         } /* End forever loop */
-
 } /* End fepcmd */
 
 /* ---------------------------------------------------------------------
@@ -2255,11 +1889,9 @@ static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
 
 static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
 { /* Begin termios2digi_h */
-
         unsigned res = 0;
 
-        if (cflag & CRTSCTS) 
-        {
+        if (cflag & CRTSCTS) {
                 ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
                 res |= ((ch->m_cts) | (ch->m_rts));
         }
@@ -2295,7 +1927,6 @@ static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
 
         unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK | 
                                 INPCK | ISTRIP|IXON|IXANY|IXOFF);
-        
         if (ch->digiext.digi_flags & DIGI_AIXON)
                 res |= IAIXON;
         return res;
@@ -2308,28 +1939,15 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
 { /* Begin termios2digi_c */
 
         unsigned res = 0;
-
-#ifdef SPEED_HACK
-        /* CL: HACK to force 115200 at 38400 and 57600 at 19200 Baud */
-        if ((cflag & CBAUD)== B38400) cflag=cflag - B38400 + B115200;
-        if ((cflag & CBAUD)== B19200) cflag=cflag - B19200 + B57600;
-#endif /* SPEED_HACK */
-
-        if (cflag & CBAUDEX)
-        { /* Begin detected CBAUDEX */
-
+        if (cflag & CBAUDEX) { /* Begin detected CBAUDEX */
                 ch->digiext.digi_flags |= DIGI_FAST;
-
                 /* -------------------------------------------------------------
                    HUPCL bit is used by FEP to indicate fast baud
                    table is to be used.
                 ----------------------------------------------------------------- */
-
                 res |= FEP_HUPCL;
-
         } /* End detected CBAUDEX */
         else ch->digiext.digi_flags &= ~DIGI_FAST; 
-
         /* -------------------------------------------------------------------
                 CBAUD has bit position 0x1000 set these days to indicate Linux
                 baud rate remap.  Digi hardware can't handle the bit assignment.
@@ -2337,7 +1955,6 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
                 bit out.
         ---------------------------------------------------------------------- */
         res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
-
         /* -------------------------------------------------------------
                 This gets a little confusing.  The Digi cards have their own
                 representation of c_cflags controling baud rate.  For the most
@@ -2357,10 +1974,8 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
                 should be checked for a screened out prior to termios2digi_c 
                 returning.  Since CLOCAL isn't used by the board this can be
                 ignored as long as the returned value is used only by Digi hardware. 
-        ----------------------------------------------------------------- */
-
-        if (cflag & CBAUDEX)
-        {
+                ----------------------------------------------------------------- */
+        if (cflag & CBAUDEX) {
                 /* -------------------------------------------------------------
                         The below code is trying to guarantee that only baud rates
                         115200 and 230400 are remapped.  We use exclusive or because
@@ -2371,138 +1986,96 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
                                 
                 if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) || 
                     (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
-                {
                         res += 1;
-                }
         }
-
         return res;
 
 } /* End termios2digi_c */
 
 /* --------------------- Begin epcaparam  ----------------------- */
 
+/* Caller must hold the locks */
 static void epcaparam(struct tty_struct *tty, struct channel *ch)
 { /* Begin epcaparam */
 
         unsigned int cmdHead;
         struct termios *ts;
-        volatile struct board_chan *bc;
+        struct board_chan *bc;
         unsigned mval, hflow, cflag, iflag;
 
         bc = ch->brdchan;
         epcaassert(bc !=0, "bc out of range");
 
         assertgwinon(ch);
-
         ts = tty->termios;
-
-        if ((ts->c_cflag & CBAUD) == 0) 
-        { /* Begin CBAUD detected */
-
-                cmdHead = bc->rin;
+        if ((ts->c_cflag & CBAUD) == 0)  { /* Begin CBAUD detected */
+                cmdHead = readw(&bc->rin);
                 bc->rout = cmdHead;
-                cmdHead = bc->tin;
-
+                cmdHead = readw(&bc->tin);
                 /* Changing baud in mid-stream transmission can be wonderful */
                 /* ---------------------------------------------------------------
                         Flush current transmit buffer by setting cmdTail pointer (tout)
                         to cmdHead pointer (tin).  Hopefully the transmit buffer is empty.
                 ----------------------------------------------------------------- */
-
                 fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
                 mval = 0;
-
-        } /* End CBAUD detected */
-        else 
-        { /* Begin CBAUD not detected */
-
+        } else  { /* Begin CBAUD not detected */
                 /* -------------------------------------------------------------------
                         c_cflags have changed but that change had nothing to do with BAUD.
                         Propagate the change to the card.
                 ---------------------------------------------------------------------- */ 
-
                 cflag = termios2digi_c(ch, ts->c_cflag);
-
-                if (cflag != ch->fepcflag) 
-                {
+                if (cflag != ch->fepcflag)  {
                         ch->fepcflag = cflag;
                         /* Set baud rate, char size, stop bits, parity */
                         fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
                 }
-
-
                 /* ----------------------------------------------------------------
                         If the user has not forced CLOCAL and if the device is not a 
                         CALLOUT device (Which is always CLOCAL) we set flags such that
                         the driver will wait on carrier detect.
                 ------------------------------------------------------------------- */
-
                 if (ts->c_cflag & CLOCAL)
-                { /* Begin it is a cud device or a ttyD device with CLOCAL on */
                         ch->asyncflags &= ~ASYNC_CHECK_CD;
-                } /* End it is a cud device or a ttyD device with CLOCAL on */
                 else
-                { /* Begin it is a ttyD device */
                         ch->asyncflags |= ASYNC_CHECK_CD;
-                } /* End it is a ttyD device */
-
                 mval = ch->m_dtr | ch->m_rts;
-
         } /* End CBAUD not detected */
-
         iflag = termios2digi_i(ch, ts->c_iflag);
-
         /* Check input mode flags */
-
-        if (iflag != ch->fepiflag) 
-        {
+        if (iflag != ch->fepiflag)  {
                 ch->fepiflag = iflag;
-
                 /* ---------------------------------------------------------------
                         Command sets channels iflag structure on the board. Such things 
                         as input soft flow control, handling of parity errors, and
                         break handling are all set here.
                 ------------------------------------------------------------------- */
-
                 /* break handling, parity handling, input stripping, flow control chars */
                 fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
         }
-
         /* ---------------------------------------------------------------
                 Set the board mint value for this channel.  This will cause hardware
                 events to be generated each time the DCD signal (Described in mint) 
                 changes.        
         ------------------------------------------------------------------- */
-        bc->mint = ch->dcd;
-
+        writeb(ch->dcd, &bc->mint);
         if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
                 if (ch->digiext.digi_flags & DIGI_FORCEDCD)
-                        bc->mint = 0;
-
-        ch->imodem = bc->mstat;
-
+                        writeb(0, &bc->mint);
+        ch->imodem = readb(&bc->mstat);
         hflow = termios2digi_h(ch, ts->c_cflag);
-
-        if (hflow != ch->hflow) 
-        {
+        if (hflow != ch->hflow)  {
                 ch->hflow = hflow;
-
                 /* --------------------------------------------------------------
                         Hard flow control has been selected but the board is not
                         using it.  Activate hard flow control now.
                 ----------------------------------------------------------------- */
-
                 fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
         }
-        
-
         mval ^= ch->modemfake & (mval ^ ch->modem);
 
-        if (ch->omodem ^ mval) 
-        {
+        if (ch->omodem ^ mval)  {
                 ch->omodem = mval;
-
                 /* --------------------------------------------------------------
                         The below command sets the DTR and RTS mstat structure.  If
                         hard flow control is NOT active these changes will drive the
@@ -2514,87 +2087,65 @@ static void epcaparam(struct tty_struct *tty, struct channel *ch)
                 /* First reset DTR & RTS; then set them */
                 fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
                 fepcmd(ch, SETMODEM, mval, 0, 0, 1);
-
         }
-
-        if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc) 
-        {
+        if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc)  {
                 ch->fepstartc = ch->startc;
                 ch->fepstopc = ch->stopc;
-
                 /* ------------------------------------------------------------
                         The XON / XOFF characters have changed; propagate these
                         changes to the card.    
                 --------------------------------------------------------------- */
-
                 fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
         }
-
-        if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca) 
-        {
+        if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca)  {
                 ch->fepstartca = ch->startca;
                 ch->fepstopca = ch->stopca;
-
                 /* ---------------------------------------------------------------
                         Similar to the above, this time the auxilarly XON / XOFF 
                         characters have changed; propagate these changes to the card.
                 ------------------------------------------------------------------ */
-
                 fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
         }
-
 } /* End epcaparam */
 
 /* --------------------- Begin receive_data  ----------------------- */
-
+/* Caller holds lock */
 static void receive_data(struct channel *ch)
 { /* Begin receive_data */
 
         unchar *rptr;
         struct termios *ts = NULL;
         struct tty_struct *tty;
-        volatile struct board_chan *bc;
-        register int dataToRead, wrapgap, bytesAvailable;
-        register unsigned int tail, head;
+        struct board_chan *bc;
+        int dataToRead, wrapgap, bytesAvailable;
+        unsigned int tail, head;
         unsigned int wrapmask;
         int rc;
 
-
         /* ---------------------------------------------------------------
                 This routine is called by doint when a receive data event 
                 has taken place.
         ------------------------------------------------------------------- */
 
         globalwinon(ch);
-
         if (ch->statusflags & RXSTOPPED)
                 return;
-
         tty = ch->tty;
         if (tty)
                 ts = tty->termios;
-
         bc = ch->brdchan;
-
-        if (!bc) 
-        {
-                printk(KERN_ERR "<Error> - bc is NULL in receive_data!\n");
-                return;
-        }
-
+        BUG_ON(!bc);
         wrapmask = ch->rxbufsize - 1;
 
         /* --------------------------------------------------------------------- 
                 Get the head and tail pointers to the receiver queue.  Wrap the 
                 head pointer if it has reached the end of the buffer.
         ------------------------------------------------------------------------ */
-
-        head = bc->rin;
+        head = readw(&bc->rin);
         head &= wrapmask;
-        tail = bc->rout & wrapmask;
+        tail = readw(&bc->rout) & wrapmask;
 
         bytesAvailable = (head - tail) & wrapmask;
-
         if (bytesAvailable == 0)
                 return;
 
@@ -2602,8 +2153,7 @@ static void receive_data(struct channel *ch)
            If CREAD bit is off or device not open, set TX tail to head
         --------------------------------------------------------------------- */
 
-        if (!tty || !ts || !(ts->c_cflag & CREAD)) 
-        {
+        if (!tty || !ts || !(ts->c_cflag & CREAD))  {
                 bc->rout = head;
                 return;
         }
@@ -2611,64 +2161,45 @@ static void receive_data(struct channel *ch)
         if (tty->flip.count == TTY_FLIPBUF_SIZE) 
                 return;
 
-        if (bc->orun) 
-        {
-                bc->orun = 0;
-                printk(KERN_WARNING "overrun! DigiBoard device %s\n",tty->name);
+        if (readb(&bc->orun)) {
+                writeb(0, &bc->orun);
+                printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",tty->name);
         }
-
         rxwinon(ch);
         rptr = tty->flip.char_buf_ptr;
         rc = tty->flip.count;
-
-        while (bytesAvailable > 0) 
-        { /* Begin while there is data on the card */
-
+        while (bytesAvailable > 0)  { /* Begin while there is data on the card */
                 wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
-
                 /* ---------------------------------------------------------------
                         Even if head has wrapped around only report the amount of
                         data to be equal to the size - tail.  Remember memcpy can't
                         automaticly wrap around the receive buffer.
                 ----------------------------------------------------------------- */
-
                 dataToRead = (wrapgap < bytesAvailable) ? wrapgap : bytesAvailable;
-
                 /* --------------------------------------------------------------
                    Make sure we don't overflow the buffer
                 ----------------------------------------------------------------- */
-
                 if ((rc + dataToRead) > TTY_FLIPBUF_SIZE)
                         dataToRead = TTY_FLIPBUF_SIZE - rc;
-
                 if (dataToRead == 0)
                         break;
-
                 /* ---------------------------------------------------------------
                         Move data read from our card into the line disciplines buffer
                         for translation if necessary.
                 ------------------------------------------------------------------ */
-
-                if ((memcpy(rptr, ch->rxptr + tail, dataToRead)) != rptr)
-                        printk(KERN_ERR "<Error> - receive_data : memcpy failed\n");
-                        
+                memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
                 rc   += dataToRead;
                 rptr += dataToRead;
                 tail = (tail + dataToRead) & wrapmask;
                 bytesAvailable -= dataToRead;
-
         } /* End while there is data on the card */
-
-
         tty->flip.count = rc;
         tty->flip.char_buf_ptr = rptr;
         globalwinon(ch);
-        bc->rout = tail;
-
+        writew(tail, &bc->rout);
         /* Must be called with global data */
         tty_schedule_flip(ch->tty); 
         return;
-
 } /* End receive_data */
 
 static int info_ioctl(struct tty_struct *tty, struct file * file,
@@ -2676,17 +2207,15 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
 {
         switch (cmd) 
         { /* Begin switch cmd */
-
                 case DIGI_GETINFO:
                 { /* Begin case DIGI_GETINFO */
-
                         struct digi_info di ;
                         int brd;
 
-                        getUser(brd, (unsigned int __user *)arg);
-
-                        if ((brd < 0) || (brd >= num_cards) || (num_cards == 0))
-                                return (-ENODEV);
+                        if(get_user(brd, (unsigned int __user *)arg))
+                                return -EFAULT;
+                        if (brd < 0 || brd >= num_cards || num_cards == 0)
+                                return -ENODEV;
 
                         memset(&di, 0, sizeof(di));
 
@@ -2694,8 +2223,9 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
                         di.status = boards[brd].status;
                         di.type = boards[brd].type ;
                         di.numports = boards[brd].numports ;
-                        di.port = boards[brd].port ;
-                        di.membase = boards[brd].membase ;
+                        /* Legacy fixups - just move along nothing to see */
+                        di.port = (unsigned char *)boards[brd].port ;
+                        di.membase = (unsigned char *)boards[brd].membase ;
 
                         if (copy_to_user((void __user *)arg, &di, sizeof (di)))
                                 return -EFAULT;
@@ -2709,39 +2239,29 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
                         int brd = arg & 0xff000000 >> 16 ; 
                         unsigned char state = arg & 0xff ; 
 
-                        if ((brd < 0) || (brd >= num_cards))
-                        {
-                                printk(KERN_ERR "<Error> - DIGI POLLER : brd not valid!\n");
+                        if (brd < 0 || brd >= num_cards) {
+                                printk(KERN_ERR "epca: DIGI POLLER : brd not valid!\n");
                                 return (-ENODEV);
                         }
-
                         digi_poller_inhibited = state ;
                         break ; 
-
                 } /* End case DIGI_POLLER */
 
                 case DIGI_INIT:
                 { /* Begin case DIGI_INIT */
-
                         /* ------------------------------------------------------------
                                 This call is made by the apps to complete the initilization
                                 of the board(s).  This routine is responsible for setting
                                 the card to its initial state and setting the drivers control
                                 fields to the sutianle settings for the card in question.
                         ---------------------------------------------------------------- */
-                
                         int crd ; 
                         for (crd = 0; crd < num_cards; crd++) 
                                 post_fep_init (crd);
-
                         break ; 
-
                 } /* End case DIGI_INIT */
-
-
                 default:
-                        return -ENOIOCTLCMD;
-
+                        return -ENOTTY;
         } /* End switch cmd */
         return (0) ;
 }
@@ -2750,43 +2270,33 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
 static int pc_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct channel *ch = (struct channel *) tty->driver_data;
-        volatile struct board_chan *bc;
+        struct board_chan *bc;
         unsigned int mstat, mflag = 0;
         unsigned long flags;
 
         if (ch)
                 bc = ch->brdchan;
         else
-        {
-                printk(KERN_ERR "<Error> - ch is NULL in pc_tiocmget!\n");
-                return(-EINVAL);
-        }
+                return -EINVAL;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&epca_lock, flags);
         globalwinon(ch);
-        mstat = bc->mstat;
+        mstat = readb(&bc->mstat);
         memoff(ch);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&epca_lock, flags);
 
         if (mstat & ch->m_dtr)
                 mflag |= TIOCM_DTR;
-
         if (mstat & ch->m_rts)
                 mflag |= TIOCM_RTS;
-
         if (mstat & ch->m_cts)
                 mflag |= TIOCM_CTS;
-
         if (mstat & ch->dsr)
                 mflag |= TIOCM_DSR;
-
         if (mstat & ch->m_ri)
                 mflag |= TIOCM_RI;
-
         if (mstat & ch->dcd)
                 mflag |= TIOCM_CD;
-
         return mflag;
 }
 
@@ -2796,13 +2306,10 @@ static int pc_tiocmset(struct tty_struct *tty, struct file *file,
         struct channel *ch = (struct channel *) tty->driver_data;
         unsigned long flags;
 
-        if (!ch) {
-                printk(KERN_ERR "<Error> - ch is NULL in pc_tiocmset!\n");
-                return(-EINVAL);
-        }
+        if (!ch)
+                return -EINVAL;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&epca_lock, flags);
         /*
          * I think this modemfake stuff is broken.  It doesn't
          * correctly reflect the behaviour desired by the TIOCM*
@@ -2824,17 +2331,14 @@ static int pc_tiocmset(struct tty_struct *tty, struct file *file,
                 ch->modemfake |= ch->m_dtr;
                 ch->modem &= ~ch->m_dtr;
         }
-
         globalwinon(ch);
-
         /*  --------------------------------------------------------------
                 The below routine generally sets up parity, baud, flow control
                 issues, etc.... It effect both control flags and input flags.
         ------------------------------------------------------------------ */
-
         epcaparam(tty,ch);
         memoff(ch);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&epca_lock, flags);
         return 0;
 }
 
@@ -2847,19 +2351,14 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
         unsigned long flags;
         unsigned int mflag, mstat;
         unsigned char startc, stopc;
-        volatile struct board_chan *bc;
+        struct board_chan *bc;
         struct channel *ch = (struct channel *) tty->driver_data;
         void __user *argp = (void __user *)arg;
         
         if (ch)
                 bc = ch->brdchan;
         else 
-        {
-                printk(KERN_ERR "<Error> - ch is NULL in pc_ioctl!\n");
-                return(-EINVAL);
-        }
-
-        save_flags(flags);
+                return -EINVAL;
 
         /* -------------------------------------------------------------------
                 For POSIX compliance we need to add more ioctls.  See tty_ioctl.c
@@ -2871,46 +2370,39 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
         { /* Begin switch cmd */
 
                 case TCGETS:
-                        if (copy_to_user(argp, 
-                                         tty->termios, sizeof(struct termios)))
+                        if (copy_to_user(argp, tty->termios, sizeof(struct termios)))
                                 return -EFAULT;
-                        return(0);
-
+                        return 0;
                 case TCGETA:
                         return get_termio(tty, argp);
-
                 case TCSBRK:    /* SVID version: non-zero arg --> no break */
-
                         retval = tty_check_change(tty);
                         if (retval)
                                 return retval;
-
                         /* Setup an event to indicate when the transmit buffer empties */
-
+                        spin_lock_irqsave(&epca_lock, flags);
                         setup_empty_event(tty,ch);              
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         tty_wait_until_sent(tty, 0);
                         if (!arg)
                                 digi_send_break(ch, HZ/4);    /* 1/4 second */
                         return 0;
-
                 case TCSBRKP:   /* support for POSIX tcsendbreak() */
-
                         retval = tty_check_change(tty);
                         if (retval)
                                 return retval;
 
                         /* Setup an event to indicate when the transmit buffer empties */
-
+                        spin_lock_irqsave(&epca_lock, flags);
                         setup_empty_event(tty,ch);              
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         tty_wait_until_sent(tty, 0);
                         digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
                         return 0;
-
                 case TIOCGSOFTCAR:
                         if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)arg))
                                 return -EFAULT;
                         return 0;
-
                 case TIOCSSOFTCAR:
                 {
                         unsigned int value;
@@ -2922,75 +2414,63 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
                                  (value ? CLOCAL : 0));
                         return 0;
                 }
-
                 case TIOCMODG:
                         mflag = pc_tiocmget(tty, file);
                         if (put_user(mflag, (unsigned long __user *)argp))
                                 return -EFAULT;
                         break;
-
                 case TIOCMODS:
                         if (get_user(mstat, (unsigned __user *)argp))
                                 return -EFAULT;
                         return pc_tiocmset(tty, file, mstat, ~mstat);
-
                 case TIOCSDTR:
+                        spin_lock_irqsave(&epca_lock, flags);
                         ch->omodem |= ch->m_dtr;
-                        cli();
                         globalwinon(ch);
                         fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
                         memoff(ch);
-                        restore_flags(flags);
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         break;
 
                 case TIOCCDTR:
+                        spin_lock_irqsave(&epca_lock, flags);
                         ch->omodem &= ~ch->m_dtr;
-                        cli();
                         globalwinon(ch);
                         fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
                         memoff(ch);
-                        restore_flags(flags);
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         break;
-
                 case DIGI_GETA:
                         if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
                                 return -EFAULT;
                         break;
-
                 case DIGI_SETAW:
                 case DIGI_SETAF:
-                        if ((cmd) == (DIGI_SETAW)) 
-                        {
+                        if (cmd == DIGI_SETAW) {
                                 /* Setup an event to indicate when the transmit buffer empties */
-
+                                spin_lock_irqsave(&epca_lock, flags);
                                 setup_empty_event(tty,ch);              
+                                spin_unlock_irqrestore(&epca_lock, flags);
                                 tty_wait_until_sent(tty, 0);
-                        }
-                        else 
-                        {
+                        } else  {
                                 /* ldisc lock already held in ioctl */
                                 if (tty->ldisc.flush_buffer)
                                         tty->ldisc.flush_buffer(tty);
                         }
-
                         /* Fall Thru */
-
                 case DIGI_SETA:
                         if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
                                 return -EFAULT;
                         
-                        if (ch->digiext.digi_flags & DIGI_ALTPIN) 
-                        {
+                        if (ch->digiext.digi_flags & DIGI_ALTPIN)  {
                                 ch->dcd = ch->m_dsr;
                                 ch->dsr = ch->m_dcd;
-                        } 
-                        else 
-                        {
+                        } else {
                                 ch->dcd = ch->m_dcd;
                                 ch->dsr = ch->m_dsr;
                         }
                 
-                        cli();
+                        spin_lock_irqsave(&epca_lock, flags);
                         globalwinon(ch);
 
                         /* -----------------------------------------------------------------
@@ -3000,25 +2480,22 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
 
                         epcaparam(tty,ch);
                         memoff(ch);
-                        restore_flags(flags);
+                        spin_unlock_irqrestore(&epca_lock, flags);
                         break;
 
                 case DIGI_GETFLOW:
                 case DIGI_GETAFLOW:
-                        cli();  
+                        spin_lock_irqsave(&epca_lock, flags);
                         globalwinon(ch);
-                        if ((cmd) == (DIGI_GETFLOW)) 
-                        {
-                                dflow.startc = bc->startc;
-                                dflow.stopc = bc->stopc;
-                        }
-                        else 
-                        {
-                                dflow.startc = bc->startca;
-                                dflow.stopc = bc->stopca;
+                        if (cmd == DIGI_GETFLOW) {
+                                dflow.startc = readb(&bc->startc);
+                                dflow.stopc = readb(&bc->stopc);
+                        } else {
+                                dflow.startc = readb(&bc->startca);
+                                dflow.stopc = readb(&bc->stopca);
                         }
                         memoff(ch);
-                        restore_flags(flags);
+                        spin_unlock_irqrestore(&epca_lock, flags);
 
                         if (copy_to_user(argp, &dflow, sizeof(dflow)))
                                 return -EFAULT;
@@ -3026,13 +2503,10 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
 
                 case DIGI_SETAFLOW:
                 case DIGI_SETFLOW:
-                        if ((cmd) == (DIGI_SETFLOW)) 
-                        {
+                        if (cmd == DIGI_SETFLOW) {
                                 startc = ch->startc;
                                 stopc = ch->stopc;
-                        } 
-                        else 
-                        {
+                        } else {
                                 startc = ch->startca;
                                 stopc = ch->stopca;
                         }
@@ -3040,40 +2514,31 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
                         if (copy_from_user(&dflow, argp, sizeof(dflow)))
                                 return -EFAULT;
 
-                        if (dflow.startc != startc || dflow.stopc != stopc) 
-                        { /* Begin  if setflow toggled */
-                                cli();
+                        if (dflow.startc != startc || dflow.stopc != stopc) { /* Begin  if setflow toggled */
+                                spin_lock_irqsave(&epca_lock, flags);
                                 globalwinon(ch);
 
-                                if ((cmd) == (DIGI_SETFLOW)) 
-                                {
+                                if (cmd == DIGI_SETFLOW) {
                                         ch->fepstartc = ch->startc = dflow.startc;
                                         ch->fepstopc = ch->stopc = dflow.stopc;
                                         fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
-                                } 
-                                else 
-                                {
+                                } else {
                                         ch->fepstartca = ch->startca = dflow.startc;
                                         ch->fepstopca  = ch->stopca = dflow.stopc;
                                         fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
                                 }
 
-                                if      (ch->statusflags & TXSTOPPED)
+                                if (ch->statusflags & TXSTOPPED)
                                         pc_start(tty);
 
                                 memoff(ch);
-                                restore_flags(flags);
-
+                                spin_unlock_irqrestore(&epca_lock, flags);
                         } /* End if setflow toggled */
                         break;
-
                 default:
                         return -ENOIOCTLCMD;
-
         } /* End switch cmd */
-
         return 0;
-
 } /* End pc_ioctl */
 
 /* --------------------- Begin pc_set_termios  ----------------------- */
@@ -3083,20 +2548,16 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
 
         struct channel *ch;
         unsigned long flags;
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if channel valid */
-
-                save_flags(flags);
-                cli();
+        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
+                spin_lock_irqsave(&epca_lock, flags);
                 globalwinon(ch);
                 epcaparam(tty, ch);
                 memoff(ch);
+                spin_unlock_irqrestore(&epca_lock, flags);
 
                 if ((old_termios->c_cflag & CRTSCTS) &&
                          ((tty->termios->c_cflag & CRTSCTS) == 0))
@@ -3106,8 +2567,6 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
                          (tty->termios->c_cflag & CLOCAL))
                         wake_up_interruptible(&ch->open_wait);
 
-                restore_flags(flags);
-
         } /* End if channel valid */
 
 } /* End pc_set_termios */
@@ -3116,29 +2575,18 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
 
 static void do_softint(void *private_)
 { /* Begin do_softint */
-
         struct channel *ch = (struct channel *) private_;
-        
-
         /* Called in response to a modem change event */
-
-        if (ch && ch->magic == EPCA_MAGIC) 
-        { /* Begin EPCA_MAGIC */
-
+        if (ch && ch->magic == EPCA_MAGIC)  { /* Begin EPCA_MAGIC */
                 struct tty_struct *tty = ch->tty;
 
-                if (tty && tty->driver_data) 
-                { 
-                        if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) 
-                        { /* Begin if clear_bit */
-
+                if (tty && tty->driver_data) {
+                        if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) { /* Begin if clear_bit */
                                 tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
                                 wake_up_interruptible(&ch->open_wait);
                                 ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
-
                         } /* End if clear_bit */
                 }
-
         } /* End EPCA_MAGIC */
 } /* End do_softint */
 
@@ -3154,82 +2602,49 @@ static void pc_stop(struct tty_struct *tty)
 
         struct channel *ch;
         unsigned long flags;
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if valid channel */
-
-                save_flags(flags); 
-                cli();
-
-                if ((ch->statusflags & TXSTOPPED) == 0) 
-                { /* Begin if transmit stop requested */
-
+        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if valid channel */
+                spin_lock_irqsave(&epca_lock, flags);
+                if ((ch->statusflags & TXSTOPPED) == 0)  { /* Begin if transmit stop requested */
                         globalwinon(ch);
-
                         /* STOP transmitting now !! */
-
                         fepcmd(ch, PAUSETX, 0, 0, 0, 0);
-
                         ch->statusflags |= TXSTOPPED;
                         memoff(ch);
-
                 } /* End if transmit stop requested */
-
-                restore_flags(flags);
-
+                spin_unlock_irqrestore(&epca_lock, flags);
         } /* End if valid channel */
-
 } /* End pc_stop */
 
 /* --------------------- Begin pc_start  ----------------------- */
 
 static void pc_start(struct tty_struct *tty)
 { /* Begin pc_start */
-
         struct channel *ch;
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if channel valid */
-
+        if ((ch = verifyChannel(tty)) != NULL) { /* Begin if channel valid */
                 unsigned long flags;
-
-                save_flags(flags);
-                cli();
-
+                spin_lock_irqsave(&epca_lock, flags);
                 /* Just in case output was resumed because of a change in Digi-flow */
-                if (ch->statusflags & TXSTOPPED) 
-                { /* Begin transmit resume requested */
-
-                        volatile struct board_chan *bc;
-
+                if (ch->statusflags & TXSTOPPED)  { /* Begin transmit resume requested */
+                        struct board_chan *bc;
                         globalwinon(ch);
                         bc = ch->brdchan;
                         if (ch->statusflags & LOWWAIT)
-                                bc->ilow = 1;
-
+                                writeb(1, &bc->ilow);
                         /* Okay, you can start transmitting again... */
-
                         fepcmd(ch, RESUMETX, 0, 0, 0, 0);
-
                         ch->statusflags &= ~TXSTOPPED;
                         memoff(ch);
-
                 } /* End transmit resume requested */
-
-                restore_flags(flags);
-
+                spin_unlock_irqrestore(&epca_lock, flags);
         } /* End if channel valid */
-
 } /* End pc_start */
 
 /* ------------------------------------------------------------------
@@ -3244,86 +2659,55 @@ ______________________________________________________________________ */
 
 static void pc_throttle(struct tty_struct * tty)
 { /* Begin pc_throttle */
-
         struct channel *ch;
         unsigned long flags;
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if channel valid */
-
-
-                save_flags(flags);
-                cli();
-
-                if ((ch->statusflags & RXSTOPPED) == 0)
-                {
+        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
+                spin_lock_irqsave(&epca_lock, flags);
+                if ((ch->statusflags & RXSTOPPED) == 0) {
                         globalwinon(ch);
                         fepcmd(ch, PAUSERX, 0, 0, 0, 0);
-
                         ch->statusflags |= RXSTOPPED;
                         memoff(ch);
                 }
-                restore_flags(flags);
-
+                spin_unlock_irqrestore(&epca_lock, flags);
         } /* End if channel valid */
-
 } /* End pc_throttle */
 
 /* --------------------- Begin unthrottle  ----------------------- */
 
 static void pc_unthrottle(struct tty_struct *tty)
 { /* Begin pc_unthrottle */
-
         struct channel *ch;
         unsigned long flags;
-        volatile struct board_chan *bc;
-
-
         /* ---------------------------------------------------------
                 verifyChannel returns the channel from the tty struct
                 if it is valid.  This serves as a sanity check.
         ------------------------------------------------------------- */
-
-        if ((ch = verifyChannel(tty)) != NULL) 
-        { /* Begin if channel valid */
-
-
+        if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
                 /* Just in case output was resumed because of a change in Digi-flow */
-                save_flags(flags);
-                cli();
-
-                if (ch->statusflags & RXSTOPPED) 
-                {
-
+                spin_lock_irqsave(&epca_lock, flags);
+                if (ch->statusflags & RXSTOPPED) {
                         globalwinon(ch);
-                        bc = ch->brdchan;
                         fepcmd(ch, RESUMERX, 0, 0, 0, 0);
-
                         ch->statusflags &= ~RXSTOPPED;
                         memoff(ch);
                 }
-                restore_flags(flags);
-
+                spin_unlock_irqrestore(&epca_lock, flags);
         } /* End if channel valid */
-
 } /* End pc_unthrottle */
 
 /* --------------------- Begin digi_send_break  ----------------------- */
 
 void digi_send_break(struct channel *ch, int msec)
 { /* Begin digi_send_break */
-
         unsigned long flags;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&epca_lock, flags);
         globalwinon(ch);
-
         /* -------------------------------------------------------------------- 
            Maybe I should send an infinite break here, schedule() for
            msec amount of time, and then stop the break.  This way,
@@ -3331,36 +2715,28 @@ void digi_send_break(struct channel *ch, int msec)
            to be called (i.e. via an ioctl()) more than once in msec amount 
            of time.  Try this for now...
         ------------------------------------------------------------------------ */
-
         fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
         memoff(ch);
-
-        restore_flags(flags);
-
+        spin_unlock_irqrestore(&epca_lock, flags);
 } /* End digi_send_break */
 
 /* --------------------- Begin setup_empty_event  ----------------------- */
 
+/* Caller MUST hold the lock */
+
 static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
 { /* Begin setup_empty_event */
 
-        volatile struct board_chan *bc = ch->brdchan;
-        unsigned long int flags;
+        struct board_chan *bc = ch->brdchan;
 
-        save_flags(flags);
-        cli();
         globalwinon(ch);
         ch->statusflags |= EMPTYWAIT;
-        
         /* ------------------------------------------------------------------
                 When set the iempty flag request a event to be generated when the 
                 transmit buffer is empty (If there is no BREAK in progress).
         --------------------------------------------------------------------- */
-
-        bc->iempty = 1;
+        writeb(1, &bc->iempty);
         memoff(ch);
-        restore_flags(flags);
-
 } /* End setup_empty_event */
 
 /* --------------------- Begin get_termio ----------------------- */
@@ -3369,10 +2745,10 @@ static int get_termio(struct tty_struct * tty, struct termio __user * termio)
 { /* Begin get_termio */
         return kernel_termios_to_user_termio(termio, tty->termios);
 } /* End get_termio */
+
 /* ---------------------- Begin epca_setup  -------------------------- */
 void epca_setup(char *str, int *ints)
 { /* Begin epca_setup */
-
         struct board_info board;
         int               index, loop, last;
         char              *temp, *t2;
@@ -3394,49 +2770,41 @@ void epca_setup(char *str, int *ints)
         for (last = 0, index = 1; index <= ints[0]; index++)
                 switch(index)
                 { /* Begin parse switch */
-
                         case 1:
                                 board.status = ints[index];
-                                
                                 /* ---------------------------------------------------------
                                         We check for 2 (As opposed to 1; because 2 is a flag
                                         instructing the driver to ignore epcaconfig.)  For this
                                         reason we check for 2.
                                 ------------------------------------------------------------ */ 
-                                if (board.status == 2)
-                                { /* Begin ignore epcaconfig as well as lilo cmd line */
+                                if (board.status == 2) { /* Begin ignore epcaconfig as well as lilo cmd line */
                                         nbdevs = 0;
                                         num_cards = 0;
                                         return;
                                 } /* End ignore epcaconfig as well as lilo cmd line */
         
-                                if (board.status > 2)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid board status 0x%x\n", board.status);
+                                if (board.status > 2) {
+                                        printk(KERN_ERR "epca_setup: Invalid board status 0x%x\n", board.status);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_BOARD_STATUS;
                                         return;
                                 }
                                 last = index;
                                 break;
-
                         case 2:
                                 board.type = ints[index];
-                                if (board.type >= PCIXEM) 
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid board type 0x%x\n", board.type);
+                                if (board.type >= PCIXEM)  {
+                                        printk(KERN_ERR "epca_setup: Invalid board type 0x%x\n", board.type);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_BOARD_TYPE;
                                         return;
                                 }
                                 last = index;
                                 break;
-
                         case 3:
                                 board.altpin = ints[index];
-                                if (board.altpin > 1)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid board altpin 0x%x\n", board.altpin);
+                                if (board.altpin > 1) {
+                                        printk(KERN_ERR "epca_setup: Invalid board altpin 0x%x\n", board.altpin);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_ALTPIN;
                                         return;
@@ -3446,9 +2814,8 @@ void epca_setup(char *str, int *ints)
 
                         case 4:
                                 board.numports = ints[index];
-                                if ((board.numports < 2) || (board.numports > 256))
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid board numports 0x%x\n", board.numports);
+                                if (board.numports < 2 || board.numports > 256) {
+                                        printk(KERN_ERR "epca_setup: Invalid board numports 0x%x\n", board.numports);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_NUM_PORTS;
                                         return;
@@ -3458,10 +2825,9 @@ void epca_setup(char *str, int *ints)
                                 break;
 
                         case 5:
-                                board.port = (unsigned char *)ints[index];
-                                if (ints[index] <= 0)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
+                                board.port = ints[index];
+                                if (ints[index] <= 0) {
+                                        printk(KERN_ERR "epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_PORT_BASE;
                                         return;
@@ -3470,10 +2836,9 @@ void epca_setup(char *str, int *ints)
                                 break;
 
                         case 6:
-                                board.membase = (unsigned char *)ints[index];
-                                if (ints[index] <= 0)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
+                                board.membase = ints[index];
+                                if (ints[index] <= 0) {
+                                        printk(KERN_ERR "epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_MEM_BASE;
                                         return;
@@ -3487,21 +2852,16 @@ void epca_setup(char *str, int *ints)
 
                 } /* End parse switch */
 
-        while (str && *str) 
-        { /* Begin while there is a string arg */
-
+        while (str && *str)  { /* Begin while there is a string arg */
                 /* find the next comma or terminator */
                 temp = str;
-
                 /* While string is not null, and a comma hasn't been found */
                 while (*temp && (*temp != ','))
                         temp++;
-
                 if (!*temp)
                         temp = NULL;
                 else
                         *temp++ = 0;
-
                 /* Set index to the number of args + 1 */
                 index = last + 1;
 
@@ -3511,12 +2871,10 @@ void epca_setup(char *str, int *ints)
                                 len = strlen(str);
                                 if (strncmp("Disable", str, len) == 0) 
                                         board.status = 0;
-                                else
-                                if (strncmp("Enable", str, len) == 0)
+                                else if (strncmp("Enable", str, len) == 0)
                                         board.status = 1;
-                                else
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid status %s\n", str);
+                                else {
+                                        printk(KERN_ERR "epca_setup: Invalid status %s\n", str);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_BOARD_STATUS;
                                         return;
@@ -3525,22 +2883,17 @@ void epca_setup(char *str, int *ints)
                                 break;
 
                         case 2:
-
                                 for(loop = 0; loop < EPCA_NUM_TYPES; loop++)
                                         if (strcmp(board_desc[loop], str) == 0)
                                                 break;
-
-
                                 /* ---------------------------------------------------------------
                                         If the index incremented above refers to a legitamate board 
                                         type set it here. 
                                 ------------------------------------------------------------------*/
-
                                 if (index < EPCA_NUM_TYPES) 
                                         board.type = loop;
-                                else
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid board type: %s\n", str);
+                                else {
+                                        printk(KERN_ERR "epca_setup: Invalid board type: %s\n", str);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_BOARD_TYPE;
                                         return;
@@ -3552,12 +2905,10 @@ void epca_setup(char *str, int *ints)
                                 len = strlen(str);
                                 if (strncmp("Disable", str, len) == 0) 
                                         board.altpin = 0;
-                                else
-                                if (strncmp("Enable", str, len) == 0)
+                                else if (strncmp("Enable", str, len) == 0)
                                         board.altpin = 1;
-                                else
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid altpin %s\n", str);
+                                else {
+                                        printk(KERN_ERR "epca_setup: Invalid altpin %s\n", str);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_ALTPIN;
                                         return;
@@ -3570,9 +2921,8 @@ void epca_setup(char *str, int *ints)
                                 while (isdigit(*t2))
                                         t2++;
 
-                                if (*t2)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid port count %s\n", str);
+                                if (*t2) {
+                                        printk(KERN_ERR "epca_setup: Invalid port count %s\n", str);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_NUM_PORTS;
                                         return;
@@ -3601,15 +2951,14 @@ void epca_setup(char *str, int *ints)
                                 while (isxdigit(*t2))
                                         t2++;
 
-                                if (*t2)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid i/o address %s\n", str);
+                                if (*t2) {
+                                        printk(KERN_ERR "epca_setup: Invalid i/o address %s\n", str);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_PORT_BASE;
                                         return;
                                 }
 
-                                board.port = (unsigned char *)simple_strtoul(str, NULL, 16);
+                                board.port = simple_strtoul(str, NULL, 16);
                                 last = index;
                                 break;
 
@@ -3618,52 +2967,38 @@ void epca_setup(char *str, int *ints)
                                 while (isxdigit(*t2))
                                         t2++;
 
-                                if (*t2)
-                                {
-                                        printk(KERN_ERR "<Error> - epca_setup: Invalid memory base %s\n",str);
+                                if (*t2) {
+                                        printk(KERN_ERR "epca_setup: Invalid memory base %s\n",str);
                                         invalid_lilo_config = 1;
                                         setup_error_code |= INVALID_MEM_BASE;
                                         return;
                                 }
-
-                                board.membase = (unsigned char *)simple_strtoul(str, NULL, 16);
+                                board.membase = simple_strtoul(str, NULL, 16);
                                 last = index;
                                 break;
-
                         default:
-                                printk(KERN_ERR "PC/Xx: Too many string parms\n");
+                                printk(KERN_ERR "epca: Too many string parms\n");
                                 return;
                 }
                 str = temp;
-
         } /* End while there is a string arg */
 
-
-        if (last < 6)  
-        {
-                printk(KERN_ERR "PC/Xx: Insufficient parms specified\n");
+        if (last < 6) {
+                printk(KERN_ERR "epca: Insufficient parms specified\n");
                 return;
         }
  
         /* I should REALLY validate the stuff here */
-
         /* Copies our local copy of board into boards */
         memcpy((void *)&boards[num_cards],(void *)&board, sizeof(board));
-
-
         /* Does this get called once per lilo arg are what ? */
-
         printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n", 
                 num_cards, board_desc[board.type], 
                 board.numports, (int)board.port, (unsigned int) board.membase);
-
         num_cards++;
-
 } /* End epca_setup */
 
 
-
-#ifdef ENABLE_PCI
 /* ------------------------ Begin init_PCI  --------------------------- */
 
 enum epic_board_types {
@@ -3685,7 +3020,6 @@ static struct {
         { PCIXRJ, 2, },
 };
 
-
 static int __devinit epca_init_one (struct pci_dev *pdev,
                                  const struct pci_device_id *ent)
 {
@@ -3711,10 +3045,8 @@ static int __devinit epca_init_one (struct pci_dev *pdev,
         boards[board_idx].status = ENABLED;
         boards[board_idx].type = epca_info_tbl[info_idx].board_type;
         boards[board_idx].numports = 0x0;
-        boards[board_idx].port =
-                (unsigned char *)((char *) addr + PCI_IO_OFFSET);
-        boards[board_idx].membase =
-                (unsigned char *)((char *) addr);
+        boards[board_idx].port = addr + PCI_IO_OFFSET;
+        boards[board_idx].membase = addr;
 
         if (!request_mem_region (addr + PCI_IO_OFFSET, 0x200000, "epca")) {
                 printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
@@ -3775,15 +3107,13 @@ static struct pci_device_id epca_pci_tbl[] = {
 MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
 
 int __init init_PCI (void)
-{ /* Begin init_PCI */
+{       /* Begin init_PCI */
         memset (&epca_driver, 0, sizeof (epca_driver));
         epca_driver.name = "epca";
         epca_driver.id_table = epca_pci_tbl;
         epca_driver.probe = epca_init_one;
 
         return pci_register_driver(&epca_driver);
-} /* End init_PCI */
-
-#endif /* ENABLE_PCI */
+}
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/epca.h b/drivers/char/epca.h
index 52205ef71314..20eeb5a70e1a 100644
--- a/drivers/char/epca.h
+++ b/drivers/char/epca.h
@@ -85,73 +85,73 @@ static char *board_desc[] =
 struct channel 
 {
         long   magic;
-        unchar boardnum;
-        unchar channelnum;
-        unchar omodem;         /* FEP output modem status     */
-        unchar imodem;         /* FEP input modem status      */
-        unchar modemfake;      /* Modem values to be forced   */
-        unchar modem;          /* Force values                */
-        unchar hflow;
-        unchar dsr;
-        unchar dcd;
-        unchar m_rts ;          /* The bits used in whatever FEP */
-        unchar m_dcd ;          /* is indiginous to this board to */
-        unchar m_dsr ;          /* represent each of the physical */
-        unchar m_cts ;          /* handshake lines */
-        unchar m_ri ;
-        unchar m_dtr ;
-        unchar stopc;
-        unchar startc;
-        unchar stopca;
-        unchar startca;
-        unchar fepstopc;
-        unchar fepstartc;
-        unchar fepstopca;
-        unchar fepstartca;
-        unchar txwin;
-        unchar rxwin;
-        ushort fepiflag;
-        ushort fepcflag;
-        ushort fepoflag;
-        ushort txbufhead;
-        ushort txbufsize;
-        ushort rxbufhead;
-        ushort rxbufsize;
+        unsigned char boardnum;
+        unsigned char channelnum;
+        unsigned char omodem;         /* FEP output modem status     */
+        unsigned char imodem;         /* FEP input modem status      */
+        unsigned char modemfake;      /* Modem values to be forced   */
+        unsigned char modem;          /* Force values                */
+        unsigned char hflow;
+        unsigned char dsr;
+        unsigned char dcd;
+        unsigned char m_rts ;           /* The bits used in whatever FEP */
+        unsigned char m_dcd ;           /* is indiginous to this board to */
+        unsigned char m_dsr ;           /* represent each of the physical */
+        unsigned char m_cts ;           /* handshake lines */
+        unsigned char m_ri ;
+        unsigned char m_dtr ;
+        unsigned char stopc;
+        unsigned char startc;
+        unsigned char stopca;
+        unsigned char startca;
+        unsigned char fepstopc;
+        unsigned char fepstartc;
+        unsigned char fepstopca;
+        unsigned char fepstartca;
+        unsigned char txwin;
+        unsigned char rxwin;
+        unsigned short fepiflag;
+        unsigned short fepcflag;
+        unsigned short fepoflag;
+        unsigned short txbufhead;
+        unsigned short txbufsize;
+        unsigned short rxbufhead;
+        unsigned short rxbufsize;
         int    close_delay;
         int    count;
         int    blocked_open;
-        ulong  event;
+        unsigned long  event;
         int    asyncflags;
         uint   dev;
-        ulong  statusflags;
-        ulong  c_iflag;
-        ulong  c_cflag;
-        ulong  c_lflag;
-        ulong  c_oflag;
-        unchar *txptr;
-        unchar *rxptr;
-        unchar *tmp_buf;
+        unsigned long  statusflags;
+        unsigned long  c_iflag;
+        unsigned long  c_cflag;
+        unsigned long  c_lflag;
+        unsigned long  c_oflag;
+        unsigned char *txptr;
+        unsigned char *rxptr;
+        unsigned char *tmp_buf;
         struct board_info           *board;
-        volatile struct board_chan  *brdchan;
+        struct board_chan           *brdchan;
         struct digi_struct          digiext;
         struct tty_struct           *tty;
         wait_queue_head_t           open_wait;
         wait_queue_head_t           close_wait;
-        struct work_struct            tqueue;
-        volatile struct global_data *mailbox;
+        struct work_struct          tqueue;
+        struct global_data          *mailbox;
 };
 
 struct board_info       
 {
-        unchar status;
-        unchar type;
-        unchar altpin;
-        ushort numports;
-        unchar *port;
-        unchar *membase;
-        unchar __iomem *re_map_port;
-        unchar *re_map_membase;
-        ulong  memory_seg;
+        unsigned char status;
+        unsigned char type;
+        unsigned char altpin;
+        unsigned short numports;
+        unsigned long port;
+        unsigned long membase;
+        unsigned char __iomem *re_map_port;
+        unsigned char *re_map_membase;
+        unsigned long  memory_seg;
         void ( * memwinon )     (struct board_info *, unsigned int) ;
         void ( * memwinoff )    (struct board_info *, unsigned int) ;
         void ( * globalwinon )  (struct channel *) ;
@@ -160,6 +160,6 @@ struct board_info
         void ( * memoff )       (struct channel *) ;
         void ( * assertgwinon ) (struct channel *) ;
         void ( * assertmemoff ) (struct channel *) ;
-        unchar poller_inhibited ;
+        unsigned char poller_inhibited ;
 };
 
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index 762fa430fb5b..a695f25e4497 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -44,7 +44,7 @@
 /*
  * The High Precision Event Timer driver.
  * This driver is closely modelled after the rtc.c driver.
- * http://www.intel.com/labs/platcomp/hpet/hpetspec.htm
+ * http://www.intel.com/hardwaredesign/hpetspec.htm
  */
 #define HPET_USER_FREQ  (64)
 #define HPET_DRIFT      (500)
@@ -712,7 +712,7 @@ static void hpet_register_interpolator(struct hpets *hpetp)
         ti->shift = 10;
         ti->addr = &hpetp->hp_hpet->hpet_mc;
         ti->frequency = hpet_time_div(hpets->hp_period);
-        ti->drift = ti->frequency * HPET_DRIFT / 1000000;
+        ti->drift = HPET_DRIFT;
         ti->mask = -1;
 
         hpetp->hp_interpolator = ti;
diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index 5ce9c6269033..33862670e285 100644
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -31,8 +31,6 @@
 #include <linux/ipmi_msgdefs.h>         /* for completion codes */
 #include "ipmi_si_sm.h"
 
-#define IPMI_BT_VERSION "v33"
-
 static int bt_debug = 0x00;     /* Production value 0, see following flags */
 
 #define BT_DEBUG_ENABLE 1
@@ -163,7 +161,8 @@ static int bt_start_transaction(struct si_sm_data *bt,
 {
         unsigned int i;
 
-        if ((size < 2) || (size > IPMI_MAX_MSG_LENGTH)) return -1;
+        if ((size < 2) || (size > IPMI_MAX_MSG_LENGTH))
+               return -1;
 
         if ((bt->state != BT_STATE_IDLE) && (bt->state != BT_STATE_HOSED))
                 return -2;
@@ -171,7 +170,8 @@ static int bt_start_transaction(struct si_sm_data *bt,
         if (bt_debug & BT_DEBUG_MSG) {
                 printk(KERN_WARNING "+++++++++++++++++++++++++++++++++++++\n");
                 printk(KERN_WARNING "BT: write seq=0x%02X:", bt->seq);
-                for (i = 0; i < size; i ++) printk (" %02x", data[i]);
+                for (i = 0; i < size; i ++)
+                       printk (" %02x", data[i]);
                 printk("\n");
         }
         bt->write_data[0] = size + 1;   /* all data plus seq byte */
@@ -210,15 +210,18 @@ static int bt_get_result(struct si_sm_data *bt,
         } else {
                 data[0] = bt->read_data[1];
                 data[1] = bt->read_data[3];
-                if (length < msg_len) bt->truncated = 1;
+                if (length < msg_len)
+                       bt->truncated = 1;
                 if (bt->truncated) {    /* can be set in read_all_bytes() */
                         data[2] = IPMI_ERR_MSG_TRUNCATED;
                         msg_len = 3;
-                } else memcpy(data + 2, bt->read_data + 4, msg_len - 2);
+                } else
+                       memcpy(data + 2, bt->read_data + 4, msg_len - 2);
 
                 if (bt_debug & BT_DEBUG_MSG) {
                         printk (KERN_WARNING "BT: res (raw)");
-                        for (i = 0; i < msg_len; i++) printk(" %02x", data[i]);
+                        for (i = 0; i < msg_len; i++)
+                               printk(" %02x", data[i]);
                         printk ("\n");
                 }
         }
@@ -231,8 +234,10 @@ static int bt_get_result(struct si_sm_data *bt,
 
 static void reset_flags(struct si_sm_data *bt)
 {
-        if (BT_STATUS & BT_H_BUSY) BT_CONTROL(BT_H_BUSY);
-        if (BT_STATUS & BT_B_BUSY) BT_CONTROL(BT_B_BUSY);
+        if (BT_STATUS & BT_H_BUSY)
+               BT_CONTROL(BT_H_BUSY);
+        if (BT_STATUS & BT_B_BUSY)
+               BT_CONTROL(BT_B_BUSY);
         BT_CONTROL(BT_CLR_WR_PTR);
         BT_CONTROL(BT_SMS_ATN);
 #ifdef DEVELOPMENT_ONLY_NOT_FOR_PRODUCTION
@@ -241,7 +246,8 @@ static void reset_flags(struct si_sm_data *bt)
                 BT_CONTROL(BT_H_BUSY);
                 BT_CONTROL(BT_B2H_ATN);
                 BT_CONTROL(BT_CLR_RD_PTR);
-                for (i = 0; i < IPMI_MAX_MSG_LENGTH + 2; i++) BMC2HOST;
+                for (i = 0; i < IPMI_MAX_MSG_LENGTH + 2; i++)
+                       BMC2HOST;
                 BT_CONTROL(BT_H_BUSY);
         }
 #endif
@@ -258,7 +264,8 @@ static inline void write_all_bytes(struct si_sm_data *bt)
                         printk (" %02x", bt->write_data[i]);
                 printk ("\n");
         }
-        for (i = 0; i < bt->write_count; i++) HOST2BMC(bt->write_data[i]);
+        for (i = 0; i < bt->write_count; i++)
+               HOST2BMC(bt->write_data[i]);
 }
 
 static inline int read_all_bytes(struct si_sm_data *bt)
@@ -278,7 +285,8 @@ static inline int read_all_bytes(struct si_sm_data *bt)
                 bt->truncated = 1;
                 return 1;       /* let next XACTION START clean it up */
         }
-        for (i = 1; i <= bt->read_count; i++) bt->read_data[i] = BMC2HOST;
+        for (i = 1; i <= bt->read_count; i++)
+               bt->read_data[i] = BMC2HOST;
         bt->read_count++;       /* account for the length byte */
 
         if (bt_debug & BT_DEBUG_MSG) {
@@ -295,7 +303,8 @@ static inline int read_all_bytes(struct si_sm_data *bt)
                 ((bt->read_data[1] & 0xF8) == (bt->write_data[1] & 0xF8)))
                         return 1;
 
-        if (bt_debug & BT_DEBUG_MSG) printk(KERN_WARNING "BT: bad packet: "
+        if (bt_debug & BT_DEBUG_MSG)
+               printk(KERN_WARNING "BT: bad packet: "
                 "want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
                 bt->write_data[1], bt->write_data[2], bt->write_data[3],
                 bt->read_data[1],  bt->read_data[2],  bt->read_data[3]);
@@ -359,7 +368,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                         time);
         bt->last_state = bt->state;
 
-        if (bt->state == BT_STATE_HOSED) return SI_SM_HOSED;
+        if (bt->state == BT_STATE_HOSED)
+               return SI_SM_HOSED;
 
         if (bt->state != BT_STATE_IDLE) {       /* do timeout test */
 
@@ -371,7 +381,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
         /* FIXME: bt_event is sometimes called with time > BT_NORMAL_TIMEOUT
               (noticed in ipmi_smic_sm.c January 2004) */
 
-                if ((time <= 0) || (time >= BT_NORMAL_TIMEOUT)) time = 100;
+                if ((time <= 0) || (time >= BT_NORMAL_TIMEOUT))
+                       time = 100;
                 bt->timeout -= time;
                 if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1)) {
                         error_recovery(bt, "timed out");
@@ -393,12 +404,14 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                         BT_CONTROL(BT_H_BUSY);
                         break;
                 }
-                if (status & BT_B2H_ATN) break;
+                if (status & BT_B2H_ATN)
+                       break;
                 bt->state = BT_STATE_WRITE_BYTES;
                 return SI_SM_CALL_WITHOUT_DELAY;        /* for logging */
 
         case BT_STATE_WRITE_BYTES:
-                if (status & (BT_B_BUSY | BT_H2B_ATN)) break;
+                if (status & (BT_B_BUSY | BT_H2B_ATN))
+                       break;
                 BT_CONTROL(BT_CLR_WR_PTR);
                 write_all_bytes(bt);
                 BT_CONTROL(BT_H2B_ATN); /* clears too fast to catch? */
@@ -406,7 +419,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                 return SI_SM_CALL_WITHOUT_DELAY; /* it MIGHT sail through */
 
         case BT_STATE_WRITE_CONSUME: /* BMCs usually blow right thru here */
-                if (status & (BT_H2B_ATN | BT_B_BUSY)) break;
+                if (status & (BT_H2B_ATN | BT_B_BUSY))
+                       break;
                 bt->state = BT_STATE_B2H_WAIT;
                 /* fall through with status */
 
@@ -415,15 +429,18 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
            generation of B2H_ATN so ALWAYS return CALL_WITH_DELAY. */
 
         case BT_STATE_B2H_WAIT:
-                if (!(status & BT_B2H_ATN)) break;
+                if (!(status & BT_B2H_ATN))
+                       break;
 
                 /* Assume ordered, uncached writes: no need to wait */
-                if (!(status & BT_H_BUSY)) BT_CONTROL(BT_H_BUSY); /* set */
+                if (!(status & BT_H_BUSY))
+                       BT_CONTROL(BT_H_BUSY); /* set */
                 BT_CONTROL(BT_B2H_ATN);         /* clear it, ACK to the BMC */
                 BT_CONTROL(BT_CLR_RD_PTR);      /* reset the queue */
                 i = read_all_bytes(bt);
                 BT_CONTROL(BT_H_BUSY);          /* clear */
-                if (!i) break;                  /* Try this state again */
+                if (!i)                         /* Try this state again */
+                       break;
                 bt->state = BT_STATE_READ_END;
                 return SI_SM_CALL_WITHOUT_DELAY;        /* for logging */
 
@@ -436,7 +453,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 
 #ifdef MAKE_THIS_TRUE_IF_NECESSARY
 
-                if (status & BT_H_BUSY) break;
+                if (status & BT_H_BUSY)
+                       break;
 #endif
                 bt->seq++;
                 bt->state = BT_STATE_IDLE;
@@ -459,7 +477,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                 break;
 
         case BT_STATE_RESET3:
-                if (bt->timeout > 0) return SI_SM_CALL_WITH_DELAY;
+                if (bt->timeout > 0)
+                       return SI_SM_CALL_WITH_DELAY;
                 bt->state = BT_STATE_RESTART;   /* printk in debug modes */
                 break;
 
@@ -485,7 +504,8 @@ static int bt_detect(struct si_sm_data *bt)
            but that's what you get from reading a bogus address, so we
            test that first.  The calling routine uses negative logic. */
 
-        if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF)) return 1;
+        if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF))
+               return 1;
         reset_flags(bt);
         return 0;
 }
@@ -501,7 +521,6 @@ static int bt_size(void)
 
 struct si_sm_handlers bt_smi_handlers =
 {
-        .version           = IPMI_BT_VERSION,
         .init_data         = bt_init_data,
         .start_transaction = bt_start_transaction,
         .get_result        = bt_get_result,
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index e0a53570fea1..883ac4352be4 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -47,8 +47,6 @@
 #include <linux/device.h>
 #include <linux/compat.h>
 
-#define IPMI_DEVINTF_VERSION "v33"
-
 struct ipmi_file_private
 {
         ipmi_user_t          user;
@@ -411,6 +409,7 @@ static int ipmi_ioctl(struct inode  *inode,
                 break;
         }
 
+        /* The next four are legacy, not per-channel. */
         case IPMICTL_SET_MY_ADDRESS_CMD:
         {
                 unsigned int val;
@@ -420,22 +419,25 @@ static int ipmi_ioctl(struct inode  *inode,
                         break;
                 }
 
-                ipmi_set_my_address(priv->user, val);
-                rv = 0;
+                rv = ipmi_set_my_address(priv->user, 0, val);
                 break;
         }
 
         case IPMICTL_GET_MY_ADDRESS_CMD:
         {
-                unsigned int val;
+                unsigned int  val;
+                unsigned char rval;
+
+                rv = ipmi_get_my_address(priv->user, 0, &rval);
+                if (rv)
+                        break;
 
-                val = ipmi_get_my_address(priv->user);
+                val = rval;
 
                 if (copy_to_user(arg, &val, sizeof(val))) {
                         rv = -EFAULT;
                         break;
                 }
-                rv = 0;
                 break;
         }
 
@@ -448,24 +450,94 @@ static int ipmi_ioctl(struct inode  *inode,
                         break;
                 }
 
-                ipmi_set_my_LUN(priv->user, val);
-                rv = 0;
+                rv = ipmi_set_my_LUN(priv->user, 0, val);
                 break;
         }
 
         case IPMICTL_GET_MY_LUN_CMD:
         {
-                unsigned int val;
+                unsigned int  val;
+                unsigned char rval;
 
-                val = ipmi_get_my_LUN(priv->user);
+                rv = ipmi_get_my_LUN(priv->user, 0, &rval);
+                if (rv)
+                        break;
+
+                val = rval;
+
+                if (copy_to_user(arg, &val, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+                break;
+        }
+
+        case IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD:
+        {
+                struct ipmi_channel_lun_address_set val;
+
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+
+                return ipmi_set_my_address(priv->user, val.channel, val.value);
+                break;
+        }
+
+        case IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD:
+        {
+                struct ipmi_channel_lun_address_set val;
+
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+
+                rv = ipmi_get_my_address(priv->user, val.channel, &val.value);
+                if (rv)
+                        break;
+
+                if (copy_to_user(arg, &val, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+                break;
+        }
+
+        case IPMICTL_SET_MY_CHANNEL_LUN_CMD:
+        {
+                struct ipmi_channel_lun_address_set val;
+
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+
+                rv = ipmi_set_my_LUN(priv->user, val.channel, val.value);
+                break;
+        }
+
+        case IPMICTL_GET_MY_CHANNEL_LUN_CMD:
+        {
+                struct ipmi_channel_lun_address_set val;
+
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+
+                rv = ipmi_get_my_LUN(priv->user, val.channel, &val.value);
+                if (rv)
+                        break;
 
                 if (copy_to_user(arg, &val, sizeof(val))) {
                         rv = -EFAULT;
                         break;
                 }
-                rv = 0;
                 break;
         }
+
         case IPMICTL_SET_TIMING_PARMS_CMD:
         {
                 struct ipmi_timing_parms parms;
@@ -748,8 +820,7 @@ static __init int init_ipmi_devintf(void)
         if (ipmi_major < 0)
                 return -EINVAL;
 
-        printk(KERN_INFO "ipmi device interface version "
-               IPMI_DEVINTF_VERSION "\n");
+        printk(KERN_INFO "ipmi device interface\n");
 
         ipmi_class = class_create(THIS_MODULE, "ipmi");
         if (IS_ERR(ipmi_class)) {
@@ -792,3 +863,5 @@ static __exit void cleanup_ipmi(void)
 module_exit(cleanup_ipmi);
 
 MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
+MODULE_DESCRIPTION("Linux device interface for the IPMI message handler.");
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index 48cce24329be..d21853a594a3 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -42,8 +42,6 @@
 #include <linux/ipmi_msgdefs.h>         /* for completion codes */
 #include "ipmi_si_sm.h"
 
-#define IPMI_KCS_VERSION "v33"
-
 /* Set this if you want a printout of why the state machine was hosed
    when it gets hosed. */
 #define DEBUG_HOSED_REASON
@@ -489,7 +487,6 @@ static void kcs_cleanup(struct si_sm_data *kcs)
 
 struct si_sm_handlers kcs_smi_handlers =
 {
-        .version           = IPMI_KCS_VERSION,
         .init_data         = init_kcs_data,
         .start_transaction = start_kcs_transaction,
         .get_result        = get_kcs_result,
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index e16c13fe698d..463351d4f942 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -47,7 +47,8 @@
 #include <linux/proc_fs.h>
 
 #define PFX "IPMI message handler: "
-#define IPMI_MSGHANDLER_VERSION "v33"
+
+#define IPMI_DRIVER_VERSION "36.0"
 
 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
 static int ipmi_init_msghandler(void);
@@ -116,7 +117,7 @@ struct seq_table
         do {                                                            \
                 seq = ((msgid >> 26) & 0x3f);                           \
                 seqid = (msgid & 0x3fffff);                             \
-        } while(0)
+        } while (0)
 
 #define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff)
 
@@ -124,6 +125,14 @@ struct ipmi_channel
 {
         unsigned char medium;
         unsigned char protocol;
+
+        /* My slave address.  This is initialized to IPMI_BMC_SLAVE_ADDR,
+           but may be changed by the user. */
+        unsigned char address;
+
+        /* My LUN.  This should generally stay the SMS LUN, but just in
+           case... */
+        unsigned char lun;
 };
 
 #ifdef CONFIG_PROC_FS
@@ -135,7 +144,7 @@ struct ipmi_proc_entry
 #endif
 
 #define IPMI_IPMB_NUM_SEQ       64
-#define IPMI_MAX_CHANNELS       8
+#define IPMI_MAX_CHANNELS       16
 struct ipmi_smi
 {
         /* What interface number are we? */
@@ -193,20 +202,6 @@ struct ipmi_smi
         struct list_head waiting_events;
         unsigned int     waiting_events_count; /* How many events in queue? */
 
-        /* This will be non-null if someone registers to receive all
-           IPMI commands (this is for interface emulation).  There
-           may not be any things in the cmd_rcvrs list above when
-           this is registered. */
-        ipmi_user_t all_cmd_rcvr;
-
-        /* My slave address.  This is initialized to IPMI_BMC_SLAVE_ADDR,
-           but may be changed by the user. */
-        unsigned char my_address;
-
-        /* My LUN.  This should generally stay the SMS LUN, but just in
-           case... */
-        unsigned char my_lun;
-
         /* The event receiver for my BMC, only really used at panic
            shutdown as a place to store this. */
         unsigned char event_receiver;
@@ -218,7 +213,7 @@ struct ipmi_smi
            interface comes in with a NULL user, call this routine with
            it.  Note that the message will still be freed by the
            caller.  This only works on the system interface. */
-        void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_smi_msg *msg);
+        void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_recv_msg *msg);
 
         /* When we are scanning the channels for an SMI, this will
            tell which channel we are scanning. */
@@ -325,7 +320,7 @@ int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
         down_read(&interfaces_sem);
         down_write(&smi_watchers_sem);
         list_add(&(watcher->link), &smi_watchers);
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 if (ipmi_interfaces[i] != NULL) {
                         watcher->new_smi(i);
                 }
@@ -458,7 +453,27 @@ unsigned int ipmi_addr_length(int addr_type)
 
 static void deliver_response(struct ipmi_recv_msg *msg)
 {
-        msg->user->handler->ipmi_recv_hndl(msg, msg->user->handler_data);
+        if (! msg->user) {
+                ipmi_smi_t    intf = msg->user_msg_data;
+                unsigned long flags;
+
+                /* Special handling for NULL users. */
+                if (intf->null_user_handler) {
+                        intf->null_user_handler(intf, msg);
+                        spin_lock_irqsave(&intf->counter_lock, flags);
+                        intf->handled_local_responses++;
+                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                } else {
+                        /* No handler, so give up. */
+                        spin_lock_irqsave(&intf->counter_lock, flags);
+                        intf->unhandled_local_responses++;
+                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                }
+                ipmi_free_recv_msg(msg);
+        } else {
+                msg->user->handler->ipmi_recv_hndl(msg,
+                                                   msg->user->handler_data);
+        }
 }
 
 /* Find the next sequence number not being used and add the given
@@ -475,9 +490,9 @@ static int intf_next_seq(ipmi_smi_t           intf,
         int          rv = 0;
         unsigned int i;
 
-        for (i=intf->curr_seq;
+        for (i = intf->curr_seq;
              (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq;
-             i=(i+1)%IPMI_IPMB_NUM_SEQ)
+             i = (i+1)%IPMI_IPMB_NUM_SEQ)
         {
                 if (! intf->seq_table[i].inuse)
                         break;
@@ -712,7 +727,7 @@ static int ipmi_destroy_user_nolock(ipmi_user_t user)
 
         /* Remove the user from the interfaces sequence table. */
         spin_lock_irqsave(&(user->intf->seq_lock), flags);
-        for (i=0; i<IPMI_IPMB_NUM_SEQ; i++) {
+        for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
                 if (user->intf->seq_table[i].inuse
                     && (user->intf->seq_table[i].recv_msg->user == user))
                 {
@@ -766,26 +781,44 @@ void ipmi_get_version(ipmi_user_t   user,
         *minor = user->intf->version_minor;
 }
 
-void ipmi_set_my_address(ipmi_user_t   user,
-                         unsigned char address)
+int ipmi_set_my_address(ipmi_user_t   user,
+                        unsigned int  channel,
+                        unsigned char address)
 {
-        user->intf->my_address = address;
+        if (channel >= IPMI_MAX_CHANNELS)
+                return -EINVAL;
+        user->intf->channels[channel].address = address;
+        return 0;
 }
 
-unsigned char ipmi_get_my_address(ipmi_user_t user)
+int ipmi_get_my_address(ipmi_user_t   user,
+                        unsigned int  channel,
+                        unsigned char *address)
 {
-        return user->intf->my_address;
+        if (channel >= IPMI_MAX_CHANNELS)
+                return -EINVAL;
+        *address = user->intf->channels[channel].address;
+        return 0;
 }
 
-void ipmi_set_my_LUN(ipmi_user_t   user,
-                     unsigned char LUN)
+int ipmi_set_my_LUN(ipmi_user_t   user,
+                    unsigned int  channel,
+                    unsigned char LUN)
 {
-        user->intf->my_lun = LUN & 0x3;
+        if (channel >= IPMI_MAX_CHANNELS)
+                return -EINVAL;
+        user->intf->channels[channel].lun = LUN & 0x3;
+        return 0;
 }
 
-unsigned char ipmi_get_my_LUN(ipmi_user_t user)
+int ipmi_get_my_LUN(ipmi_user_t   user,
+                    unsigned int  channel,
+                    unsigned char *address)
 {
-        return user->intf->my_lun;
+        if (channel >= IPMI_MAX_CHANNELS)
+                return -EINVAL;
+        *address = user->intf->channels[channel].lun;
+        return 0;
 }
 
 int ipmi_set_gets_events(ipmi_user_t user, int val)
@@ -828,11 +861,6 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
 
         read_lock(&(user->intf->users_lock));
         write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags);
-        if (user->intf->all_cmd_rcvr != NULL) {
-                rv = -EBUSY;
-                goto out_unlock;
-        }
-
         /* Make sure the command/netfn is not already registered. */
         list_for_each_entry(cmp, &(user->intf->cmd_rcvrs), link) {
                 if ((cmp->netfn == netfn) && (cmp->cmd == cmd)) {
@@ -847,7 +875,7 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
                 rcvr->user = user;
                 list_add_tail(&(rcvr->link), &(user->intf->cmd_rcvrs));
         }
- out_unlock:
+
         write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags);
         read_unlock(&(user->intf->users_lock));
 
@@ -1213,7 +1241,7 @@ static inline int i_ipmi_request(ipmi_user_t          user,
                 unsigned char         ipmb_seq;
                 long                  seqid;
 
-                if (addr->channel > IPMI_NUM_CHANNELS) {
+                if (addr->channel >= IPMI_NUM_CHANNELS) {
                         spin_lock_irqsave(&intf->counter_lock, flags);
                         intf->sent_invalid_commands++;
                         spin_unlock_irqrestore(&intf->counter_lock, flags);
@@ -1331,7 +1359,7 @@ static inline int i_ipmi_request(ipmi_user_t          user,
 #ifdef DEBUG_MSGING
         {
                 int m;
-                for (m=0; m<smi_msg->data_size; m++)
+                for (m = 0; m < smi_msg->data_size; m++)
                         printk(" %2.2x", smi_msg->data[m]);
                 printk("\n");
         }
@@ -1346,6 +1374,18 @@ static inline int i_ipmi_request(ipmi_user_t          user,
         return rv;
 }
 
+static int check_addr(ipmi_smi_t       intf,
+                      struct ipmi_addr *addr,
+                      unsigned char    *saddr,
+                      unsigned char    *lun)
+{
+        if (addr->channel >= IPMI_MAX_CHANNELS)
+                return -EINVAL;
+        *lun = intf->channels[addr->channel].lun;
+        *saddr = intf->channels[addr->channel].address;
+        return 0;
+}
+
 int ipmi_request_settime(ipmi_user_t      user,
                          struct ipmi_addr *addr,
                          long             msgid,
@@ -1355,6 +1395,14 @@ int ipmi_request_settime(ipmi_user_t      user,
                          int              retries,
                          unsigned int     retry_time_ms)
 {
+        unsigned char saddr, lun;
+        int           rv;
+
+        if (! user)
+                return -EINVAL;
+        rv = check_addr(user->intf, addr, &saddr, &lun);
+        if (rv)
+                return rv;
         return i_ipmi_request(user,
                               user->intf,
                               addr,
@@ -1363,8 +1411,8 @@ int ipmi_request_settime(ipmi_user_t      user,
                               user_msg_data,
                               NULL, NULL,
                               priority,
-                              user->intf->my_address,
-                              user->intf->my_lun,
+                              saddr,
+                              lun,
                               retries,
                               retry_time_ms);
 }
@@ -1378,6 +1426,14 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
                              struct ipmi_recv_msg *supplied_recv,
                              int                  priority)
 {
+        unsigned char saddr, lun;
+        int           rv;
+
+        if (! user)
+                return -EINVAL;
+        rv = check_addr(user->intf, addr, &saddr, &lun);
+        if (rv)
+                return rv;
         return i_ipmi_request(user,
                               user->intf,
                               addr,
@@ -1387,8 +1443,8 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
                               supplied_smi,
                               supplied_recv,
                               priority,
-                              user->intf->my_address,
-                              user->intf->my_lun,
+                              saddr,
+                              lun,
                               -1, 0);
 }
 
@@ -1397,8 +1453,15 @@ static int ipmb_file_read_proc(char *page, char **start, off_t off,
 {
         char       *out = (char *) page;
         ipmi_smi_t intf = data;
+        int        i;
+        int        rv= 0;
 
-        return sprintf(out, "%x\n", intf->my_address);
+        for (i = 0; i < IPMI_MAX_CHANNELS; i++)
+                rv += sprintf(out+rv, "%x ", intf->channels[i].address);
+        out[rv-1] = '\n'; /* Replace the final space with a newline */
+        out[rv] = '\0';
+        rv++;
+        return rv;
 }
 
 static int version_file_read_proc(char *page, char **start, off_t off,
@@ -1588,29 +1651,30 @@ send_channel_info_cmd(ipmi_smi_t intf, int chan)
                               (struct ipmi_addr *) &si,
                               0,
                               &msg,
-                              NULL,
+                              intf,
                               NULL,
                               NULL,
                               0,
-                              intf->my_address,
-                              intf->my_lun,
+                              intf->channels[0].address,
+                              intf->channels[0].lun,
                               -1, 0);
 }
 
 static void
-channel_handler(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
+channel_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
 {
         int rv = 0;
         int chan;
 
-        if ((msg->rsp[0] == (IPMI_NETFN_APP_RESPONSE << 2))
-            && (msg->rsp[1] == IPMI_GET_CHANNEL_INFO_CMD))
+        if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
+            && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE)
+            && (msg->msg.cmd == IPMI_GET_CHANNEL_INFO_CMD))
         {
                 /* It's the one we want */
-                if (msg->rsp[2] != 0) {
+                if (msg->msg.data[0] != 0) {
                         /* Got an error from the channel, just go on. */
 
-                        if (msg->rsp[2] == IPMI_INVALID_COMMAND_ERR) {
+                        if (msg->msg.data[0] == IPMI_INVALID_COMMAND_ERR) {
                                 /* If the MC does not support this
                                    command, that is legal.  We just
                                    assume it has one IPMB at channel
@@ -1627,13 +1691,13 @@ channel_handler(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
                         }
                         goto next_channel;
                 }
-                if (msg->rsp_size < 6) {
+                if (msg->msg.data_len < 4) {
                         /* Message not big enough, just go on. */
                         goto next_channel;
                 }
                 chan = intf->curr_channel;
-                intf->channels[chan].medium = msg->rsp[4] & 0x7f;
-                intf->channels[chan].protocol = msg->rsp[5] & 0x1f;
+                intf->channels[chan].medium = msg->msg.data[2] & 0x7f;
+                intf->channels[chan].protocol = msg->msg.data[3] & 0x1f;
 
         next_channel:
                 intf->curr_channel++;
@@ -1691,22 +1755,24 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         rv = -ENOMEM;
 
         down_write(&interfaces_sem);
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 if (ipmi_interfaces[i] == NULL) {
                         new_intf->intf_num = i;
                         new_intf->version_major = version_major;
                         new_intf->version_minor = version_minor;
-                        if (slave_addr == 0)
-                                new_intf->my_address = IPMI_BMC_SLAVE_ADDR;
-                        else
-                                new_intf->my_address = slave_addr;
-                        new_intf->my_lun = 2;  /* the SMS LUN. */
+                        for (j = 0; j < IPMI_MAX_CHANNELS; j++) {
+                                new_intf->channels[j].address
+                                        = IPMI_BMC_SLAVE_ADDR;
+                                new_intf->channels[j].lun = 2;
+                        }
+                        if (slave_addr != 0)
+                                new_intf->channels[0].address = slave_addr;
                         rwlock_init(&(new_intf->users_lock));
                         INIT_LIST_HEAD(&(new_intf->users));
                         new_intf->handlers = handlers;
                         new_intf->send_info = send_info;
                         spin_lock_init(&(new_intf->seq_lock));
-                        for (j=0; j<IPMI_IPMB_NUM_SEQ; j++) {
+                        for (j = 0; j < IPMI_IPMB_NUM_SEQ; j++) {
                                 new_intf->seq_table[j].inuse = 0;
                                 new_intf->seq_table[j].seqid = 0;
                         }
@@ -1722,7 +1788,6 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
                         rwlock_init(&(new_intf->cmd_rcvr_lock));
                         init_waitqueue_head(&new_intf->waitq);
                         INIT_LIST_HEAD(&(new_intf->cmd_rcvrs));
-                        new_intf->all_cmd_rcvr = NULL;
 
                         spin_lock_init(&(new_intf->counter_lock));
 
@@ -1814,7 +1879,7 @@ static void clean_up_interface_data(ipmi_smi_t intf)
         free_recv_msg_list(&(intf->waiting_events));
         free_cmd_rcvr_list(&(intf->cmd_rcvrs));
 
-        for (i=0; i<IPMI_IPMB_NUM_SEQ; i++) {
+        for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
                 if ((intf->seq_table[i].inuse)
                     && (intf->seq_table[i].recv_msg))
                 {
@@ -1833,7 +1898,7 @@ int ipmi_unregister_smi(ipmi_smi_t intf)
         down_write(&interfaces_sem);
         if (list_empty(&(intf->users)))
         {
-                for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+                for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                         if (ipmi_interfaces[i] == intf) {
                                 remove_proc_entries(intf);
                                 spin_lock_irqsave(&interfaces_lock, flags);
@@ -1960,15 +2025,11 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
 
         read_lock(&(intf->cmd_rcvr_lock));
         
-        if (intf->all_cmd_rcvr) {
-                user = intf->all_cmd_rcvr;
-        } else {
-                /* Find the command/netfn. */
-                list_for_each_entry(rcvr, &(intf->cmd_rcvrs), link) {
-                        if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
-                                user = rcvr->user;
-                                break;
-                        }
+        /* Find the command/netfn. */
+        list_for_each_entry(rcvr, &(intf->cmd_rcvrs), link) {
+                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
+                        user = rcvr->user;
+                        break;
                 }
         }
         read_unlock(&(intf->cmd_rcvr_lock));
@@ -1985,7 +2046,7 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
                 msg->data[3] = msg->rsp[6];
                 msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3);
                 msg->data[5] = ipmb_checksum(&(msg->data[3]), 2);
-                msg->data[6] = intf->my_address;
+                msg->data[6] = intf->channels[msg->rsp[3] & 0xf].address;
                 /* rqseq/lun */
                 msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3);
                 msg->data[8] = msg->rsp[8]; /* cmd */
@@ -1997,7 +2058,7 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
         {
                 int m;
                 printk("Invalid command:");
-                for (m=0; m<msg->data_size; m++)
+                for (m = 0; m < msg->data_size; m++)
                         printk(" %2.2x", msg->data[m]);
                 printk("\n");
         }
@@ -2145,15 +2206,11 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
 
         read_lock(&(intf->cmd_rcvr_lock));
 
-        if (intf->all_cmd_rcvr) {
-                user = intf->all_cmd_rcvr;
-        } else {
-                /* Find the command/netfn. */
-                list_for_each_entry(rcvr, &(intf->cmd_rcvrs), link) {
-                        if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
-                                user = rcvr->user;
-                                break;
-                        }
+        /* Find the command/netfn. */
+        list_for_each_entry(rcvr, &(intf->cmd_rcvrs), link) {
+                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) {
+                        user = rcvr->user;
+                        break;
                 }
         }
         read_unlock(&(intf->cmd_rcvr_lock));
@@ -2330,6 +2387,14 @@ static int handle_bmc_rsp(ipmi_smi_t          intf,
         unsigned long        flags;
 
         recv_msg = (struct ipmi_recv_msg *) msg->user_data;
+        if (recv_msg == NULL)
+        {
+                printk(KERN_WARNING"IPMI message received with no owner. This\n"
+                        "could be because of a malformed message, or\n"
+                        "because of a hardware error.  Contact your\n"
+                        "hardware vender for assistance\n");
+                return 0;
+        }
 
         /* Make sure the user still exists. */
         list_for_each_entry(user, &(intf->users), link) {
@@ -2340,19 +2405,11 @@ static int handle_bmc_rsp(ipmi_smi_t          intf,
                 }
         }
 
-        if (!found) {
-                /* Special handling for NULL users. */
-                if (!recv_msg->user && intf->null_user_handler){
-                        intf->null_user_handler(intf, msg);
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->handled_local_responses++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
-                }else{
-                        /* The user for the message went away, so give up. */
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->unhandled_local_responses++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
-                }
+        if ((! found) && recv_msg->user) {
+                /* The user for the message went away, so give up. */
+                spin_lock_irqsave(&intf->counter_lock, flags);
+                intf->unhandled_local_responses++;
+                spin_unlock_irqrestore(&intf->counter_lock, flags);
                 ipmi_free_recv_msg(recv_msg);
         } else {
                 struct ipmi_system_interface_addr *smi_addr;
@@ -2392,7 +2449,7 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
 #ifdef DEBUG_MSGING
         int m;
         printk("Recv:");
-        for (m=0; m<msg->rsp_size; m++)
+        for (m = 0; m < msg->rsp_size; m++)
                 printk(" %2.2x", msg->rsp[m]);
         printk("\n");
 #endif
@@ -2626,7 +2683,7 @@ smi_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg,
         {
                 int m;
                 printk("Resend: ");
-                for (m=0; m<smi_msg->data_size; m++)
+                for (m = 0; m < smi_msg->data_size; m++)
                         printk(" %2.2x", smi_msg->data[m]);
                 printk("\n");
         }
@@ -2647,7 +2704,7 @@ ipmi_timeout_handler(long timeout_period)
         INIT_LIST_HEAD(&timeouts);
 
         spin_lock(&interfaces_lock);
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 intf = ipmi_interfaces[i];
                 if (intf == NULL)
                         continue;
@@ -2672,7 +2729,7 @@ ipmi_timeout_handler(long timeout_period)
                    have timed out, putting them in the timeouts
                    list. */
                 spin_lock_irqsave(&(intf->seq_lock), flags);
-                for (j=0; j<IPMI_IPMB_NUM_SEQ; j++) {
+                for (j = 0; j < IPMI_IPMB_NUM_SEQ; j++) {
                         struct seq_table *ent = &(intf->seq_table[j]);
                         if (!ent->inuse)
                                 continue;
@@ -2712,7 +2769,7 @@ ipmi_timeout_handler(long timeout_period)
                                 spin_unlock(&intf->counter_lock);
                                 smi_msg = smi_from_recv_msg(intf,
                                                 ent->recv_msg, j, ent->seqid);
-                                if(!smi_msg)
+                                if (! smi_msg)
                                         continue;
 
                                 spin_unlock_irqrestore(&(intf->seq_lock),flags);
@@ -2743,7 +2800,7 @@ static void ipmi_request_event(void)
         int        i;
 
         spin_lock(&interfaces_lock);
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 intf = ipmi_interfaces[i];
                 if (intf == NULL)
                         continue;
@@ -2838,28 +2895,30 @@ static void dummy_recv_done_handler(struct ipmi_recv_msg *msg)
 }
 
 #ifdef CONFIG_IPMI_PANIC_STRING
-static void event_receiver_fetcher(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
+static void event_receiver_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
 {
-        if ((msg->rsp[0] == (IPMI_NETFN_SENSOR_EVENT_RESPONSE << 2))
-            && (msg->rsp[1] == IPMI_GET_EVENT_RECEIVER_CMD)
-            && (msg->rsp[2] == IPMI_CC_NO_ERROR))
+        if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
+            && (msg->msg.netfn == IPMI_NETFN_SENSOR_EVENT_RESPONSE)
+            && (msg->msg.cmd == IPMI_GET_EVENT_RECEIVER_CMD)
+            && (msg->msg.data[0] == IPMI_CC_NO_ERROR))
         {
                 /* A get event receiver command, save it. */
-                intf->event_receiver = msg->rsp[3];
-                intf->event_receiver_lun = msg->rsp[4] & 0x3;
+                intf->event_receiver = msg->msg.data[1];
+                intf->event_receiver_lun = msg->msg.data[2] & 0x3;
         }
 }
 
-static void device_id_fetcher(ipmi_smi_t intf, struct ipmi_smi_msg *msg)
+static void device_id_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
 {
-        if ((msg->rsp[0] == (IPMI_NETFN_APP_RESPONSE << 2))
-            && (msg->rsp[1] == IPMI_GET_DEVICE_ID_CMD)
-            && (msg->rsp[2] == IPMI_CC_NO_ERROR))
+        if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
+            && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE)
+            && (msg->msg.cmd == IPMI_GET_DEVICE_ID_CMD)
+            && (msg->msg.data[0] == IPMI_CC_NO_ERROR))
         {
                 /* A get device id command, save if we are an event
                    receiver or generator. */
-                intf->local_sel_device = (msg->rsp[8] >> 2) & 1;
-                intf->local_event_generator = (msg->rsp[8] >> 5) & 1;
+                intf->local_sel_device = (msg->msg.data[6] >> 2) & 1;
+                intf->local_event_generator = (msg->msg.data[6] >> 5) & 1;
         }
 }
 #endif
@@ -2903,7 +2962,7 @@ static void send_panic_events(char *str)
         recv_msg.done = dummy_recv_done_handler;
 
         /* For every registered interface, send the event. */
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 intf = ipmi_interfaces[i];
                 if (intf == NULL)
                         continue;
@@ -2915,12 +2974,12 @@ static void send_panic_events(char *str)
                                &addr,
                                0,
                                &msg,
-                               NULL,
+                               intf,
                                &smi_msg,
                                &recv_msg,
                                0,
-                               intf->my_address,
-                               intf->my_lun,
+                               intf->channels[0].address,
+                               intf->channels[0].lun,
                                0, 1); /* Don't retry, and don't wait. */
         }
 
@@ -2930,7 +2989,7 @@ static void send_panic_events(char *str)
         if (!str) 
                 return;
 
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 char                  *p = str;
                 struct ipmi_ipmb_addr *ipmb;
                 int                   j;
@@ -2961,12 +3020,12 @@ static void send_panic_events(char *str)
                                &addr,
                                0,
                                &msg,
-                               NULL,
+                               intf,
                                &smi_msg,
                                &recv_msg,
                                0,
-                               intf->my_address,
-                               intf->my_lun,
+                               intf->channels[0].address,
+                               intf->channels[0].lun,
                                0, 1); /* Don't retry, and don't wait. */
 
                 if (intf->local_event_generator) {
@@ -2981,12 +3040,12 @@ static void send_panic_events(char *str)
                                        &addr,
                                        0,
                                        &msg,
-                                       NULL,
+                                       intf,
                                        &smi_msg,
                                        &recv_msg,
                                        0,
-                                       intf->my_address,
-                                       intf->my_lun,
+                                       intf->channels[0].address,
+                                       intf->channels[0].lun,
                                        0, 1); /* no retry, and no wait. */
                 }
                 intf->null_user_handler = NULL;
@@ -2996,7 +3055,7 @@ static void send_panic_events(char *str)
                    be zero, and it must not be my address. */
                 if (((intf->event_receiver & 1) == 0)
                     && (intf->event_receiver != 0)
-                    && (intf->event_receiver != intf->my_address))
+                    && (intf->event_receiver != intf->channels[0].address))
                 {
                         /* The event receiver is valid, send an IPMB
                            message. */
@@ -3031,7 +3090,7 @@ static void send_panic_events(char *str)
                         data[0] = 0;
                         data[1] = 0;
                         data[2] = 0xf0; /* OEM event without timestamp. */
-                        data[3] = intf->my_address;
+                        data[3] = intf->channels[0].address;
                         data[4] = j++; /* sequence # */
                         /* Always give 11 bytes, so strncpy will fill
                            it with zeroes for me. */
@@ -3043,12 +3102,12 @@ static void send_panic_events(char *str)
                                        &addr,
                                        0,
                                        &msg,
-                                       NULL,
+                                       intf,
                                        &smi_msg,
                                        &recv_msg,
                                        0,
-                                       intf->my_address,
-                                       intf->my_lun,
+                                       intf->channels[0].address,
+                                       intf->channels[0].lun,
                                        0, 1); /* no retry, and no wait. */
                 }
         }       
@@ -3070,7 +3129,7 @@ static int panic_event(struct notifier_block *this,
         has_paniced = 1;
 
         /* For every registered interface, set it to run to completion. */
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 intf = ipmi_interfaces[i];
                 if (intf == NULL)
                         continue;
@@ -3099,9 +3158,9 @@ static int ipmi_init_msghandler(void)
                 return 0;
 
         printk(KERN_INFO "ipmi message handler version "
-               IPMI_MSGHANDLER_VERSION "\n");
+               IPMI_DRIVER_VERSION "\n");
 
-        for (i=0; i<MAX_IPMI_INTERFACES; i++) {
+        for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
                 ipmi_interfaces[i] = NULL;
         }
 
@@ -3171,6 +3230,9 @@ module_exit(cleanup_ipmi);
 
 module_init(ipmi_init_msghandler_mod);
 MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
+MODULE_DESCRIPTION("Incoming and outgoing message routing for an IPMI interface.");
+MODULE_VERSION(IPMI_DRIVER_VERSION);
 
 EXPORT_SYMBOL(ipmi_create_user);
 EXPORT_SYMBOL(ipmi_destroy_user);
diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index f951c30236c9..e82a96ba396b 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -42,7 +42,6 @@
 #include <linux/ipmi_smi.h>
 
 #define PFX "IPMI poweroff: "
-#define IPMI_POWEROFF_VERSION   "v33"
 
 /* Where to we insert our poweroff function? */
 extern void (*pm_power_off)(void);
@@ -53,16 +52,17 @@ extern void (*pm_power_off)(void);
 #define IPMI_CHASSIS_POWER_CYCLE        0x02    /* power cycle */
 
 /* the IPMI data command */
-static int poweroff_control = IPMI_CHASSIS_POWER_DOWN;
+static int poweroff_powercycle;
 
 /* parameter definition to allow user to flag power cycle */
-module_param(poweroff_control, int, IPMI_CHASSIS_POWER_DOWN);
-MODULE_PARM_DESC(poweroff_control, " Set to 2 to enable power cycle instead of power down. Power cycle is contingent on hardware support, otherwise it defaults back to power down.");
+module_param(poweroff_powercycle, int, 0);
+MODULE_PARM_DESC(poweroff_powercycles, " Set to non-zero to enable power cycle instead of power down. Power cycle is contingent on hardware support, otherwise it defaults back to power down.");
 
 /* Stuff from the get device id command. */
 static unsigned int mfg_id;
 static unsigned int prod_id;
 static unsigned char capabilities;
+static unsigned char ipmi_version;
 
 /* We use our own messages for this operation, we don't let the system
    allocate them, since we may be in a panic situation.  The whole
@@ -338,6 +338,25 @@ static void ipmi_poweroff_cpi1 (ipmi_user_t user)
 }
 
 /*
+ * ipmi_dell_chassis_detect()
+ * Dell systems with IPMI < 1.5 don't set the chassis capability bit
+ * but they can handle a chassis poweroff or powercycle command.
+ */
+
+#define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00}
+static int ipmi_dell_chassis_detect (ipmi_user_t user)
+{
+        const char ipmi_version_major = ipmi_version & 0xF;
+        const char ipmi_version_minor = (ipmi_version >> 4) & 0xF;
+        const char mfr[3]=DELL_IANA_MFR_ID;
+        if (!memcmp(mfr, &mfg_id, sizeof(mfr)) &&
+            ipmi_version_major <= 1 &&
+            ipmi_version_minor < 5)
+                return 1;
+        return 0;
+}
+
+/*
  * Standard chassis support
  */
 
@@ -366,37 +385,34 @@ static void ipmi_poweroff_chassis (ipmi_user_t user)
 
  powercyclefailed:
         printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
-                ((poweroff_control != IPMI_CHASSIS_POWER_CYCLE) ? "down" : "cycle"));
+                (poweroff_powercycle ? "cycle" : "down"));
 
         /*
          * Power down
          */
         send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST;
         send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD;
-        data[0] = poweroff_control;
+        if (poweroff_powercycle)
+                data[0] = IPMI_CHASSIS_POWER_CYCLE;
+        else
+                data[0] = IPMI_CHASSIS_POWER_DOWN;
         send_msg.data = data;
         send_msg.data_len = sizeof(data);
         rv = ipmi_request_in_rc_mode(user,
                                      (struct ipmi_addr *) &smi_addr,
                                      &send_msg);
         if (rv) {
-                switch (poweroff_control) {
-                        case IPMI_CHASSIS_POWER_CYCLE:
-                                /* power cycle failed, default to power down */
-                                printk(KERN_ERR PFX "Unable to send chassis power " \
-                                        "cycle message, IPMI error 0x%x\n", rv);
-                                poweroff_control = IPMI_CHASSIS_POWER_DOWN;
-                                goto powercyclefailed;
-
-                        case IPMI_CHASSIS_POWER_DOWN:
-                        default:
-                                printk(KERN_ERR PFX "Unable to send chassis power " \
-                                        "down message, IPMI error 0x%x\n", rv);
-                                break;
+                if (poweroff_powercycle) {
+                        /* power cycle failed, default to power down */
+                        printk(KERN_ERR PFX "Unable to send chassis power " \
+                               "cycle message, IPMI error 0x%x\n", rv);
+                        poweroff_powercycle = 0;
+                        goto powercyclefailed;
                 }
-        }
 
-        return;
+                printk(KERN_ERR PFX "Unable to send chassis power " \
+                       "down message, IPMI error 0x%x\n", rv);
+        }
 }
 
 
@@ -414,6 +430,9 @@ static struct poweroff_function poweroff_functions[] = {
         { .platform_type        = "CPI1",
           .detect               = ipmi_cpi1_detect,
           .poweroff_func        = ipmi_poweroff_cpi1 },
+        { .platform_type        = "chassis",
+          .detect               = ipmi_dell_chassis_detect,
+          .poweroff_func        = ipmi_poweroff_chassis },
         /* Chassis should generally be last, other things should override
            it. */
         { .platform_type        = "chassis",
@@ -499,10 +518,11 @@ static void ipmi_po_new_smi(int if_num)
         prod_id = (halt_recv_msg.msg.data[10]
                    | (halt_recv_msg.msg.data[11] << 8));
         capabilities = halt_recv_msg.msg.data[6];
+        ipmi_version = halt_recv_msg.msg.data[5];
 
 
         /* Scan for a poweroff method */
-        for (i=0; i<NUM_PO_FUNCS; i++) {
+        for (i = 0; i < NUM_PO_FUNCS; i++) {
                 if (poweroff_functions[i].detect(ipmi_user))
                         goto found;
         }
@@ -538,39 +558,35 @@ static struct ipmi_smi_watcher smi_watcher =
 
 
 #ifdef CONFIG_PROC_FS
-/* displays properties to proc */
-static int proc_read_chassctrl(char *page, char **start, off_t off, int count,
-                               int *eof, void *data)
-{
-        return sprintf(page, "%d\t[ 0=powerdown 2=powercycle ]\n",
-                        poweroff_control);
-}
+#include <linux/sysctl.h>
+
+static ctl_table ipmi_table[] = {
+        { .ctl_name     = DEV_IPMI_POWEROFF_POWERCYCLE,
+          .procname     = "poweroff_powercycle",
+          .data         = &poweroff_powercycle,
+          .maxlen       = sizeof(poweroff_powercycle),
+          .mode         = 0644,
+          .proc_handler = &proc_dointvec },
+        { }
+};
 
-/* process property writes from proc */
-static int proc_write_chassctrl(struct file *file, const char *buffer,
-                                unsigned long count, void *data)
-{
-        int          rv = count;
-        unsigned int newval = 0;
-
-        sscanf(buffer, "%d", &newval);
-        switch (newval) {
-                case IPMI_CHASSIS_POWER_CYCLE:
-                        printk(KERN_INFO PFX "power cycle is now enabled\n");
-                        poweroff_control = newval;
-                        break;
-
-                case IPMI_CHASSIS_POWER_DOWN:
-                        poweroff_control = IPMI_CHASSIS_POWER_DOWN;
-                        break;
-
-                default:
-                        rv = -EINVAL;
-                        break;
-        }
+static ctl_table ipmi_dir_table[] = {
+        { .ctl_name     = DEV_IPMI,
+          .procname     = "ipmi",
+          .mode         = 0555,
+          .child        = ipmi_table },
+        { }
+};
 
-        return rv;
-}
+static ctl_table ipmi_root_table[] = {
+        { .ctl_name     = CTL_DEV,
+          .procname     = "dev",
+          .mode         = 0555,
+          .child        = ipmi_dir_table },
+        { }
+};
+
+static struct ctl_table_header *ipmi_table_header;
 #endif /* CONFIG_PROC_FS */
 
 /*
@@ -578,42 +594,32 @@ static int proc_write_chassctrl(struct file *file, const char *buffer,
  */
 static int ipmi_poweroff_init (void)
 {
-        int                   rv;
-        struct proc_dir_entry *file;
+        int rv;
 
         printk ("Copyright (C) 2004 MontaVista Software -"
-                " IPMI Powerdown via sys_reboot version "
-                IPMI_POWEROFF_VERSION ".\n");
-
-        switch (poweroff_control) {
-                case IPMI_CHASSIS_POWER_CYCLE:
-                        printk(KERN_INFO PFX "Power cycle is enabled.\n");
-                        break;
-
-                case IPMI_CHASSIS_POWER_DOWN:
-                default:
-                        poweroff_control = IPMI_CHASSIS_POWER_DOWN;
-                        break;
+                " IPMI Powerdown via sys_reboot.\n");
+
+        if (poweroff_powercycle)
+                printk(KERN_INFO PFX "Power cycle is enabled.\n");
+
+#ifdef CONFIG_PROC_FS
+        ipmi_table_header = register_sysctl_table(ipmi_root_table, 1);
+        if (!ipmi_table_header) {
+                printk(KERN_ERR PFX "Unable to register powercycle sysctl\n");
+                rv = -ENOMEM;
+                goto out_err;
         }
+#endif
 
+#ifdef CONFIG_PROC_FS
         rv = ipmi_smi_watcher_register(&smi_watcher);
+#endif
         if (rv) {
+                unregister_sysctl_table(ipmi_table_header);
                 printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
                 goto out_err;
         }
 
-#ifdef CONFIG_PROC_FS
-        file = create_proc_entry("poweroff_control", 0, proc_ipmi_root);
-        if (!file) {
-                printk(KERN_ERR PFX "Unable to create proc power control\n");
-        } else {
-                file->nlink = 1;
-                file->read_proc = proc_read_chassctrl;
-                file->write_proc = proc_write_chassctrl;
-                file->owner = THIS_MODULE;
-        }
-#endif
-
  out_err:
         return rv;
 }
@@ -624,7 +630,7 @@ static __exit void ipmi_poweroff_cleanup(void)
         int rv;
 
 #ifdef CONFIG_PROC_FS
-        remove_proc_entry("poweroff_control", proc_ipmi_root);
+        unregister_sysctl_table(ipmi_table_header);
 #endif
 
         ipmi_smi_watcher_unregister(&smi_watcher);
@@ -642,3 +648,5 @@ module_exit(ipmi_poweroff_cleanup);
 
 module_init(ipmi_poweroff_init);
 MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
+MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot");
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index a44b97304e95..1abec687865c 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -61,11 +61,11 @@
 # endif
 static inline void add_usec_to_timer(struct timer_list *t, long v)
 {
-        t->sub_expires += nsec_to_arch_cycle(v * 1000);
-        while (t->sub_expires >= arch_cycles_per_jiffy)
+        t->arch_cycle_expires += nsec_to_arch_cycle(v * 1000);
+        while (t->arch_cycle_expires >= arch_cycles_per_jiffy)
         {
                 t->expires++;
-                t->sub_expires -= arch_cycles_per_jiffy;
+                t->arch_cycle_expires -= arch_cycles_per_jiffy;
         }
 }
 #endif
@@ -75,8 +75,7 @@ static inline void add_usec_to_timer(struct timer_list *t, long v)
 #include <asm/io.h>
 #include "ipmi_si_sm.h"
 #include <linux/init.h>
-
-#define IPMI_SI_VERSION "v33"
+#include <linux/dmi.h>
 
 /* Measure times between events in the driver. */
 #undef DEBUG_TIMING
@@ -109,6 +108,21 @@ enum si_type {
     SI_KCS, SI_SMIC, SI_BT
 };
 
+struct ipmi_device_id {
+        unsigned char device_id;
+        unsigned char device_revision;
+        unsigned char firmware_revision_1;
+        unsigned char firmware_revision_2;
+        unsigned char ipmi_version;
+        unsigned char additional_device_support;
+        unsigned char manufacturer_id[3];
+        unsigned char product_id[2];
+        unsigned char aux_firmware_revision[4];
+} __attribute__((packed));
+
+#define ipmi_version_major(v) ((v)->ipmi_version & 0xf)
+#define ipmi_version_minor(v) ((v)->ipmi_version >> 4)
+
 struct smi_info
 {
         ipmi_smi_t             intf;
@@ -131,12 +145,24 @@ struct smi_info
         void (*irq_cleanup)(struct smi_info *info);
         unsigned int io_size;
 
+        /* Per-OEM handler, called from handle_flags().
+           Returns 1 when handle_flags() needs to be re-run
+           or 0 indicating it set si_state itself.
+        */
+        int (*oem_data_avail_handler)(struct smi_info *smi_info);
+
         /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
            is set to hold the flags until we are done handling everything
            from the flags. */
 #define RECEIVE_MSG_AVAIL       0x01
 #define EVENT_MSG_BUFFER_FULL   0x02
 #define WDT_PRE_TIMEOUT_INT     0x08
+#define OEM0_DATA_AVAIL     0x20
+#define OEM1_DATA_AVAIL     0x40
+#define OEM2_DATA_AVAIL     0x80
+#define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
+                             OEM1_DATA_AVAIL | \
+                             OEM2_DATA_AVAIL)
         unsigned char       msg_flags;
 
         /* If set to true, this will request events the next time the
@@ -175,11 +201,7 @@ struct smi_info
            interrupts. */
         int interrupt_disabled;
 
-        unsigned char ipmi_si_dev_rev;
-        unsigned char ipmi_si_fw_rev_major;
-        unsigned char ipmi_si_fw_rev_minor;
-        unsigned char ipmi_version_major;
-        unsigned char ipmi_version_minor;
+        struct ipmi_device_id device_id;
 
         /* Slave address, could be reported from DMI. */
         unsigned char slave_addr;
@@ -245,7 +267,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                 entry = smi_info->xmit_msgs.next;
         }
 
-        if (!entry) {
+        if (! entry) {
                 smi_info->curr_msg = NULL;
                 rv = SI_SM_IDLE;
         } else {
@@ -306,7 +328,7 @@ static void start_clear_flags(struct smi_info *smi_info)
    memory, we will re-enable the interrupt. */
 static inline void disable_si_irq(struct smi_info *smi_info)
 {
-        if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
+        if ((smi_info->irq) && (! smi_info->interrupt_disabled)) {
                 disable_irq_nosync(smi_info->irq);
                 smi_info->interrupt_disabled = 1;
         }
@@ -322,6 +344,7 @@ static inline void enable_si_irq(struct smi_info *smi_info)
 
 static void handle_flags(struct smi_info *smi_info)
 {
+ retry:
         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
                 /* Watchdog pre-timeout */
                 spin_lock(&smi_info->count_lock);
@@ -336,7 +359,7 @@ static void handle_flags(struct smi_info *smi_info)
         } else if (smi_info->msg_flags & RECEIVE_MSG_AVAIL) {
                 /* Messages available. */
                 smi_info->curr_msg = ipmi_alloc_smi_msg();
-                if (!smi_info->curr_msg) {
+                if (! smi_info->curr_msg) {
                         disable_si_irq(smi_info);
                         smi_info->si_state = SI_NORMAL;
                         return;
@@ -355,7 +378,7 @@ static void handle_flags(struct smi_info *smi_info)
         } else if (smi_info->msg_flags & EVENT_MSG_BUFFER_FULL) {
                 /* Events available. */
                 smi_info->curr_msg = ipmi_alloc_smi_msg();
-                if (!smi_info->curr_msg) {
+                if (! smi_info->curr_msg) {
                         disable_si_irq(smi_info);
                         smi_info->si_state = SI_NORMAL;
                         return;
@@ -371,6 +394,10 @@ static void handle_flags(struct smi_info *smi_info)
                         smi_info->curr_msg->data,
                         smi_info->curr_msg->data_size);
                 smi_info->si_state = SI_GETTING_EVENTS;
+        } else if (smi_info->msg_flags & OEM_DATA_AVAIL) {
+                if (smi_info->oem_data_avail_handler)
+                        if (smi_info->oem_data_avail_handler(smi_info))
+                                goto retry;
         } else {
                 smi_info->si_state = SI_NORMAL;
         }
@@ -387,7 +414,7 @@ static void handle_transaction_done(struct smi_info *smi_info)
 #endif
         switch (smi_info->si_state) {
         case SI_NORMAL:
-                if (!smi_info->curr_msg)
+                if (! smi_info->curr_msg)
                         break;
 
                 smi_info->curr_msg->rsp_size
@@ -761,18 +788,20 @@ static void si_restart_short_timer(struct smi_info *smi_info)
 #if defined(CONFIG_HIGH_RES_TIMERS)
         unsigned long flags;
         unsigned long jiffies_now;
+        unsigned long seq;
 
         if (del_timer(&(smi_info->si_timer))) {
                 /* If we don't delete the timer, then it will go off
                    immediately, anyway.  So we only process if we
                    actually delete the timer. */
 
-                /* We already have irqsave on, so no need for it
-                   here. */
-                read_lock(&xtime_lock);
-                jiffies_now = jiffies;
-                smi_info->si_timer.expires = jiffies_now;
-                smi_info->si_timer.sub_expires = get_arch_cycles(jiffies_now);
+                do {
+                        seq = read_seqbegin_irqsave(&xtime_lock, flags);
+                        jiffies_now = jiffies;
+                        smi_info->si_timer.expires = jiffies_now;
+                        smi_info->si_timer.arch_cycle_expires
+                                = get_arch_cycles(jiffies_now);
+                } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 
                 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
 
@@ -826,15 +855,19 @@ static void smi_timeout(unsigned long data)
         /* If the state machine asks for a short delay, then shorten
            the timer timeout. */
         if (smi_result == SI_SM_CALL_WITH_DELAY) {
+#if defined(CONFIG_HIGH_RES_TIMERS)
+                unsigned long seq;
+#endif
                 spin_lock_irqsave(&smi_info->count_lock, flags);
                 smi_info->short_timeouts++;
                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
 #if defined(CONFIG_HIGH_RES_TIMERS)
-                read_lock(&xtime_lock);
-                smi_info->si_timer.expires = jiffies;
-                smi_info->si_timer.sub_expires
-                        = get_arch_cycles(smi_info->si_timer.expires);
-                read_unlock(&xtime_lock);
+                do {
+                        seq = read_seqbegin_irqsave(&xtime_lock, flags);
+                        smi_info->si_timer.expires = jiffies;
+                        smi_info->si_timer.arch_cycle_expires
+                                = get_arch_cycles(smi_info->si_timer.expires);
+                } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
                 add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
 #else
                 smi_info->si_timer.expires = jiffies + 1;
@@ -845,7 +878,7 @@ static void smi_timeout(unsigned long data)
                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
 #if defined(CONFIG_HIGH_RES_TIMERS)
-                smi_info->si_timer.sub_expires = 0;
+                smi_info->si_timer.arch_cycle_expires = 0;
 #endif
         }
 
@@ -1014,7 +1047,7 @@ static int std_irq_setup(struct smi_info *info)
 {
         int rv;
 
-        if (!info->irq)
+        if (! info->irq)
                 return 0;
 
         if (info->si_type == SI_BT) {
@@ -1023,7 +1056,7 @@ static int std_irq_setup(struct smi_info *info)
                                  SA_INTERRUPT,
                                  DEVICE_NAME,
                                  info);
-                if (!rv)
+                if (! rv)
                         /* Enable the interrupt in the BT interface. */
                         info->io.outputb(&info->io, IPMI_BT_INTMASK_REG,
                                          IPMI_BT_INTMASK_ENABLE_IRQ_BIT);
@@ -1048,7 +1081,7 @@ static int std_irq_setup(struct smi_info *info)
 
 static void std_irq_cleanup(struct smi_info *info)
 {
-        if (!info->irq)
+        if (! info->irq)
                 return;
 
         if (info->si_type == SI_BT)
@@ -1121,7 +1154,7 @@ static int port_setup(struct smi_info *info)
         unsigned int *addr = info->io.info;
         int           mapsize;
 
-        if (!addr || (!*addr))
+        if (! addr || (! *addr))
                 return -ENODEV;
 
         info->io_cleanup = port_cleanup;
@@ -1164,15 +1197,15 @@ static int try_init_port(int intf_num, struct smi_info **new_info)
 {
         struct smi_info *info;
 
-        if (!ports[intf_num])
+        if (! ports[intf_num])
                 return -ENODEV;
 
-        if (!is_new_interface(intf_num, IPMI_IO_ADDR_SPACE,
+        if (! is_new_interface(intf_num, IPMI_IO_ADDR_SPACE,
                               ports[intf_num]))
                 return -ENODEV;
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
-        if (!info) {
+        if (! info) {
                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (1)\n");
                 return -ENOMEM;
         }
@@ -1182,10 +1215,10 @@ static int try_init_port(int intf_num, struct smi_info **new_info)
         info->io.info = &(ports[intf_num]);
         info->io.addr = NULL;
         info->io.regspacing = regspacings[intf_num];
-        if (!info->io.regspacing)
+        if (! info->io.regspacing)
                 info->io.regspacing = DEFAULT_REGSPACING;
         info->io.regsize = regsizes[intf_num];
-        if (!info->io.regsize)
+        if (! info->io.regsize)
                 info->io.regsize = DEFAULT_REGSPACING;
         info->io.regshift = regshifts[intf_num];
         info->irq = 0;
@@ -1270,7 +1303,7 @@ static int mem_setup(struct smi_info *info)
         unsigned long *addr = info->io.info;
         int           mapsize;
 
-        if (!addr || (!*addr))
+        if (! addr || (! *addr))
                 return -ENODEV;
 
         info->io_cleanup = mem_cleanup;
@@ -1325,15 +1358,15 @@ static int try_init_mem(int intf_num, struct smi_info **new_info)
 {
         struct smi_info *info;
 
-        if (!addrs[intf_num])
+        if (! addrs[intf_num])
                 return -ENODEV;
 
-        if (!is_new_interface(intf_num, IPMI_MEM_ADDR_SPACE,
+        if (! is_new_interface(intf_num, IPMI_MEM_ADDR_SPACE,
                               addrs[intf_num]))
                 return -ENODEV;
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
-        if (!info) {
+        if (! info) {
                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (2)\n");
                 return -ENOMEM;
         }
@@ -1343,10 +1376,10 @@ static int try_init_mem(int intf_num, struct smi_info **new_info)
         info->io.info = &addrs[intf_num];
         info->io.addr = NULL;
         info->io.regspacing = regspacings[intf_num];
-        if (!info->io.regspacing)
+        if (! info->io.regspacing)
                 info->io.regspacing = DEFAULT_REGSPACING;
         info->io.regsize = regsizes[intf_num];
-        if (!info->io.regsize)
+        if (! info->io.regsize)
                 info->io.regsize = DEFAULT_REGSPACING;
         info->io.regshift = regshifts[intf_num];
         info->irq = 0;
@@ -1404,7 +1437,7 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
 {
         acpi_status status;
 
-        if (!info->irq)
+        if (! info->irq)
                 return 0;
 
         /* FIXME - is level triggered right? */
@@ -1428,7 +1461,7 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
 
 static void acpi_gpe_irq_cleanup(struct smi_info *info)
 {
-        if (!info->irq)
+        if (! info->irq)
                 return;
 
         acpi_remove_gpe_handler(NULL, info->irq, &ipmi_acpi_gpe);
@@ -1504,10 +1537,10 @@ static int try_init_acpi(int intf_num, struct smi_info **new_info)
                 addr_space = IPMI_MEM_ADDR_SPACE;
         else
                 addr_space = IPMI_IO_ADDR_SPACE;
-        if (!is_new_interface(-1, addr_space, spmi->addr.address))
+        if (! is_new_interface(-1, addr_space, spmi->addr.address))
                 return -ENODEV;
 
-        if (!spmi->addr.register_bit_width) {
+        if (! spmi->addr.register_bit_width) {
                 acpi_failure = 1;
                 return -ENODEV;
         }
@@ -1534,7 +1567,7 @@ static int try_init_acpi(int intf_num, struct smi_info **new_info)
         }
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
-        if (!info) {
+        if (! info) {
                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
                 return -ENOMEM;
         }
@@ -1610,22 +1643,15 @@ typedef struct dmi_ipmi_data
 static dmi_ipmi_data_t dmi_data[SI_MAX_DRIVERS];
 static int dmi_data_entries;
 
-typedef struct dmi_header
-{
-        u8      type;
-        u8      length;
-        u16     handle;
-} dmi_header_t;
-
-static int decode_dmi(dmi_header_t __iomem *dm, int intf_num)
+static int __init decode_dmi(struct dmi_header *dm, int intf_num)
 {
-        u8              __iomem *data = (u8 __iomem *)dm;
+        u8              *data = (u8 *)dm;
         unsigned long   base_addr;
         u8              reg_spacing;
-        u8              len = readb(&dm->length);
+        u8              len = dm->length;
         dmi_ipmi_data_t *ipmi_data = dmi_data+intf_num;
 
-        ipmi_data->type = readb(&data[4]);
+        ipmi_data->type = data[4];
 
         memcpy(&base_addr, data+8, sizeof(unsigned long));
         if (len >= 0x11) {
@@ -1640,12 +1666,12 @@ static int decode_dmi(dmi_header_t __iomem *dm, int intf_num)
                 }
                 /* If bit 4 of byte 0x10 is set, then the lsb for the address
                    is odd. */
-                ipmi_data->base_addr = base_addr | ((readb(&data[0x10]) & 0x10) >> 4);
+                ipmi_data->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
 
-                ipmi_data->irq = readb(&data[0x11]);
+                ipmi_data->irq = data[0x11];
 
                 /* The top two bits of byte 0x10 hold the register spacing. */
-                reg_spacing = (readb(&data[0x10]) & 0xC0) >> 6;
+                reg_spacing = (data[0x10] & 0xC0) >> 6;
                 switch(reg_spacing){
                 case 0x00: /* Byte boundaries */
                     ipmi_data->offset = 1;
@@ -1673,7 +1699,7 @@ static int decode_dmi(dmi_header_t __iomem *dm, int intf_num)
                 ipmi_data->offset = 1;
         }
 
-        ipmi_data->slave_addr = readb(&data[6]);
+        ipmi_data->slave_addr = data[6];
 
         if (is_new_interface(-1, ipmi_data->addr_space,ipmi_data->base_addr)) {
                 dmi_data_entries++;
@@ -1685,94 +1711,29 @@ static int decode_dmi(dmi_header_t __iomem *dm, int intf_num)
         return -1;
 }
 
-static int dmi_table(u32 base, int len, int num)
+static void __init dmi_find_bmc(void)
 {
-        u8                __iomem *buf;
-        struct dmi_header __iomem *dm;
-        u8                __iomem *data;
-        int               i=1;
-        int               status=-1;
+        struct dmi_device *dev = NULL;
         int               intf_num = 0;
 
-        buf = ioremap(base, len);
-        if(buf==NULL)
-                return -1;
-
-        data = buf;
-
-        while(i<num && (data - buf) < len)
-        {
-                dm=(dmi_header_t __iomem *)data;
-
-                if((data-buf+readb(&dm->length)) >= len)
-                        break;
-
-                if (readb(&dm->type) == 38) {
-                        if (decode_dmi(dm, intf_num) == 0) {
-                                intf_num++;
-                                if (intf_num >= SI_MAX_DRIVERS)
-                                        break;
-                        }
-                }
-
-                data+=readb(&dm->length);
-                while((data-buf) < len && (readb(data)||readb(data+1)))
-                        data++;
-                data+=2;
-                i++;
-        }
-        iounmap(buf);
-
-        return status;
-}
-
-static inline int dmi_checksum(u8 *buf)
-{
-        u8   sum=0;
-        int  a;
-
-        for(a=0; a<15; a++)
-                sum+=buf[a];
-        return (sum==0);
-}
-
-static int dmi_decode(void)
-{
-        u8   buf[15];
-        u32  fp=0xF0000;
-
-#ifdef CONFIG_SIMNOW
-        return -1;
-#endif
-
-        while(fp < 0xFFFFF)
-        {
-                isa_memcpy_fromio(buf, fp, 15);
-                if(memcmp(buf, "_DMI_", 5)==0 && dmi_checksum(buf))
-                {
-                        u16 num=buf[13]<<8|buf[12];
-                        u16 len=buf[7]<<8|buf[6];
-                        u32 base=buf[11]<<24|buf[10]<<16|buf[9]<<8|buf[8];
+        while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
+                if (intf_num >= SI_MAX_DRIVERS)
+                        break;
 
-                        if(dmi_table(base, len, num) == 0)
-                                return 0;
-                }
-                fp+=16;
+                decode_dmi((struct dmi_header *) dev->device_data, intf_num++);
         }
-
-        return -1;
 }
 
 static int try_init_smbios(int intf_num, struct smi_info **new_info)
 {
-        struct smi_info   *info;
-        dmi_ipmi_data_t   *ipmi_data = dmi_data+intf_num;
-        char              *io_type;
+        struct smi_info *info;
+        dmi_ipmi_data_t *ipmi_data = dmi_data+intf_num;
+        char            *io_type;
 
         if (intf_num >= dmi_data_entries)
                 return -ENODEV;
 
-        switch(ipmi_data->type) {
+        switch (ipmi_data->type) {
                 case 0x01: /* KCS */
                         si_type[intf_num] = "kcs";
                         break;
@@ -1787,7 +1748,7 @@ static int try_init_smbios(int intf_num, struct smi_info **new_info)
         }
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
-        if (!info) {
+        if (! info) {
                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (4)\n");
                 return -ENOMEM;
         }
@@ -1811,7 +1772,7 @@ static int try_init_smbios(int intf_num, struct smi_info **new_info)
 
         regspacings[intf_num] = ipmi_data->offset;
         info->io.regspacing = regspacings[intf_num];
-        if (!info->io.regspacing)
+        if (! info->io.regspacing)
                 info->io.regspacing = DEFAULT_REGSPACING;
         info->io.regsize = DEFAULT_REGSPACING;
         info->io.regshift = regshifts[intf_num];
@@ -1853,14 +1814,14 @@ static int find_pci_smic(int intf_num, struct smi_info **new_info)
 
         pci_smic_checked = 1;
 
-        if ((pci_dev = pci_get_device(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID,
-                                       NULL)))
-                ;
-        else if ((pci_dev = pci_get_class(PCI_ERMC_CLASSCODE, NULL)) &&
-                 pci_dev->subsystem_vendor == PCI_HP_VENDOR_ID)
-                fe_rmc = 1;
-        else
-                return -ENODEV;
+        pci_dev = pci_get_device(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID, NULL);
+        if (! pci_dev) {
+                pci_dev = pci_get_class(PCI_ERMC_CLASSCODE, NULL);
+                if (pci_dev && (pci_dev->subsystem_vendor == PCI_HP_VENDOR_ID))
+                        fe_rmc = 1;
+                else
+                        return -ENODEV;
+        }
 
         error = pci_read_config_word(pci_dev, PCI_MMC_ADDR_CW, &base_addr);
         if (error)
@@ -1873,7 +1834,7 @@ static int find_pci_smic(int intf_num, struct smi_info **new_info)
         }
 
         /* Bit 0: 1 specifies programmed I/O, 0 specifies memory mapped I/O */
-        if (!(base_addr & 0x0001))
+        if (! (base_addr & 0x0001))
         {
                 pci_dev_put(pci_dev);
                 printk(KERN_ERR
@@ -1883,17 +1844,17 @@ static int find_pci_smic(int intf_num, struct smi_info **new_info)
         }
 
         base_addr &= 0xFFFE;
-        if (!fe_rmc)
+        if (! fe_rmc)
                 /* Data register starts at base address + 1 in eRMC */
                 ++base_addr;
 
-        if (!is_new_interface(-1, IPMI_IO_ADDR_SPACE, base_addr)) {
+        if (! is_new_interface(-1, IPMI_IO_ADDR_SPACE, base_addr)) {
                 pci_dev_put(pci_dev);
                 return -ENODEV;
         }
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
-        if (!info) {
+        if (! info) {
                 pci_dev_put(pci_dev);
                 printk(KERN_ERR "ipmi_si: Could not allocate SI data (5)\n");
                 return -ENOMEM;
@@ -1904,7 +1865,7 @@ static int find_pci_smic(int intf_num, struct smi_info **new_info)
         ports[intf_num] = base_addr;
         info->io.info = &(ports[intf_num]);
         info->io.regspacing = regspacings[intf_num];
-        if (!info->io.regspacing)
+        if (! info->io.regspacing)
                 info->io.regspacing = DEFAULT_REGSPACING;
         info->io.regsize = DEFAULT_REGSPACING;
         info->io.regshift = regshifts[intf_num];
@@ -1925,7 +1886,7 @@ static int find_pci_smic(int intf_num, struct smi_info **new_info)
 static int try_init_plug_and_play(int intf_num, struct smi_info **new_info)
 {
 #ifdef CONFIG_PCI
-        if (find_pci_smic(intf_num, new_info)==0)
+        if (find_pci_smic(intf_num, new_info) == 0)
                 return 0;
 #endif
         /* Include other methods here. */
@@ -1943,7 +1904,7 @@ static int try_get_dev_id(struct smi_info *smi_info)
         int               rv = 0;
 
         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
-        if (!resp)
+        if (! resp)
                 return -ENOMEM;
 
         /* Do a Get Device ID command, since it comes back with some
@@ -1992,11 +1953,8 @@ static int try_get_dev_id(struct smi_info *smi_info)
         }
 
         /* Record info from the get device id, in case we need it. */
-        smi_info->ipmi_si_dev_rev = resp[4] & 0xf;
-        smi_info->ipmi_si_fw_rev_major = resp[5] & 0x7f;
-        smi_info->ipmi_si_fw_rev_minor = resp[6];
-        smi_info->ipmi_version_major = resp[7] & 0xf;
-        smi_info->ipmi_version_minor = resp[7] >> 4;
+        memcpy(&smi_info->device_id, &resp[3],
+               min_t(unsigned long, resp_len-3, sizeof(smi_info->device_id)));
 
  out:
         kfree(resp);
@@ -2028,7 +1986,7 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
         struct smi_info *smi = data;
 
         out += sprintf(out, "interrupts_enabled:    %d\n",
-                       smi->irq && !smi->interrupt_disabled);
+                       smi->irq && ! smi->interrupt_disabled);
         out += sprintf(out, "short_timeouts:        %ld\n",
                        smi->short_timeouts);
         out += sprintf(out, "long_timeouts:         %ld\n",
@@ -2057,6 +2015,73 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
         return (out - ((char *) page));
 }
 
+/*
+ * oem_data_avail_to_receive_msg_avail
+ * @info - smi_info structure with msg_flags set
+ *
+ * Converts flags from OEM_DATA_AVAIL to RECEIVE_MSG_AVAIL
+ * Returns 1 indicating need to re-run handle_flags().
+ */
+static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
+{
+        smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
+                                RECEIVE_MSG_AVAIL);
+        return 1;
+}
+
+/*
+ * setup_dell_poweredge_oem_data_handler
+ * @info - smi_info.device_id must be populated
+ *
+ * Systems that match, but have firmware version < 1.40 may assert
+ * OEM0_DATA_AVAIL on their own, without being told via Set Flags that
+ * it's safe to do so.  Such systems will de-assert OEM1_DATA_AVAIL
+ * upon receipt of IPMI_GET_MSG_CMD, so we should treat these flags
+ * as RECEIVE_MSG_AVAIL instead.
+ *
+ * As Dell has no plans to release IPMI 1.5 firmware that *ever*
+ * assert the OEM[012] bits, and if it did, the driver would have to
+ * change to handle that properly, we don't actually check for the
+ * firmware version.
+ * Device ID = 0x20                BMC on PowerEdge 8G servers
+ * Device Revision = 0x80
+ * Firmware Revision1 = 0x01       BMC version 1.40
+ * Firmware Revision2 = 0x40       BCD encoded
+ * IPMI Version = 0x51             IPMI 1.5
+ * Manufacturer ID = A2 02 00      Dell IANA
+ *
+ */
+#define DELL_POWEREDGE_8G_BMC_DEVICE_ID  0x20
+#define DELL_POWEREDGE_8G_BMC_DEVICE_REV 0x80
+#define DELL_POWEREDGE_8G_BMC_IPMI_VERSION 0x51
+#define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00}
+static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
+{
+        struct ipmi_device_id *id = &smi_info->device_id;
+        const char mfr[3]=DELL_IANA_MFR_ID;
+        if (! memcmp(mfr, id->manufacturer_id, sizeof(mfr))
+            && (id->device_id       == DELL_POWEREDGE_8G_BMC_DEVICE_ID)
+            && (id->device_revision == DELL_POWEREDGE_8G_BMC_DEVICE_REV)
+            && (id->ipmi_version    == DELL_POWEREDGE_8G_BMC_IPMI_VERSION))
+        {
+                smi_info->oem_data_avail_handler =
+                        oem_data_avail_to_receive_msg_avail;
+        }
+}
+
+/*
+ * setup_oem_data_handler
+ * @info - smi_info.device_id must be filled in already
+ *
+ * Fills in smi_info.device_id.oem_data_available_handler
+ * when we know what function to use there.
+ */
+
+static void setup_oem_data_handler(struct smi_info *smi_info)
+{
+        setup_dell_poweredge_oem_data_handler(smi_info);
+}
+
 /* Returns 0 if initialized, or negative on an error. */
 static int init_one_smi(int intf_num, struct smi_info **smi)
 {
@@ -2068,19 +2093,15 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
         if (rv)
                 rv = try_init_port(intf_num, &new_smi);
 #ifdef CONFIG_ACPI_INTERPRETER
-        if ((rv) && (si_trydefaults)) {
+        if (rv && si_trydefaults)
                 rv = try_init_acpi(intf_num, &new_smi);
-        }
 #endif
 #ifdef CONFIG_X86
-        if ((rv) && (si_trydefaults)) {
+        if (rv && si_trydefaults)
                 rv = try_init_smbios(intf_num, &new_smi);
-        }
 #endif
-        if ((rv) && (si_trydefaults)) {
+        if (rv && si_trydefaults)
                 rv = try_init_plug_and_play(intf_num, &new_smi);
-        }
-
 
         if (rv)
                 return rv;
@@ -2090,7 +2111,7 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
         new_smi->si_sm = NULL;
         new_smi->handlers = NULL;
 
-        if (!new_smi->irq_setup) {
+        if (! new_smi->irq_setup) {
                 new_smi->irq = irqs[intf_num];
                 new_smi->irq_setup = std_irq_setup;
                 new_smi->irq_cleanup = std_irq_cleanup;
@@ -2124,7 +2145,7 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
 
         /* Allocate the state machine's data and initialize it. */
         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
-        if (!new_smi->si_sm) {
+        if (! new_smi->si_sm) {
                 printk(" Could not allocate state machine memory\n");
                 rv = -ENOMEM;
                 goto out_err;
@@ -2155,6 +2176,8 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
         if (rv)
                 goto out_err;
 
+        setup_oem_data_handler(new_smi);
+
         /* Try to claim any interrupts. */
         new_smi->irq_setup(new_smi);
 
@@ -2188,8 +2211,8 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
 
         rv = ipmi_register_smi(&handlers,
                                new_smi,
-                               new_smi->ipmi_version_major,
-                               new_smi->ipmi_version_minor,
+                               ipmi_version_major(&new_smi->device_id),
+                               ipmi_version_minor(&new_smi->device_id),
                                new_smi->slave_addr,
                                &(new_smi->intf));
         if (rv) {
@@ -2230,7 +2253,7 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
 
         /* Wait for the timer to stop.  This avoids problems with race
            conditions removing the timer here. */
-        while (!new_smi->timer_stopped) {
+        while (! new_smi->timer_stopped) {
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 schedule_timeout(1);
         }
@@ -2270,7 +2293,7 @@ static __init int init_ipmi_si(void)
         /* Parse out the si_type string into its components. */
         str = si_type_str;
         if (*str != '\0') {
-                for (i=0; (i<SI_MAX_PARMS) && (*str != '\0'); i++) {
+                for (i = 0; (i < SI_MAX_PARMS) && (*str != '\0'); i++) {
                         si_type[i] = str;
                         str = strchr(str, ',');
                         if (str) {
@@ -2282,22 +2305,14 @@ static __init int init_ipmi_si(void)
                 }
         }
 
-        printk(KERN_INFO "IPMI System Interface driver version "
-               IPMI_SI_VERSION);
-        if (kcs_smi_handlers.version)
-                printk(", KCS version %s", kcs_smi_handlers.version);
-        if (smic_smi_handlers.version)
-                printk(", SMIC version %s", smic_smi_handlers.version);
-        if (bt_smi_handlers.version)
-                printk(", BT version %s", bt_smi_handlers.version);
-        printk("\n");
+        printk(KERN_INFO "IPMI System Interface driver.\n");
 
 #ifdef CONFIG_X86
-        dmi_decode();
+        dmi_find_bmc();
 #endif
 
         rv = init_one_smi(0, &(smi_infos[pos]));
-        if (rv && !ports[0] && si_trydefaults) {
+        if (rv && ! ports[0] && si_trydefaults) {
                 /* If we are trying defaults and the initial port is
                    not set, then set it. */
                 si_type[0] = "kcs";
@@ -2319,7 +2334,7 @@ static __init int init_ipmi_si(void)
         if (rv == 0)
                 pos++;
 
-        for (i=1; i < SI_MAX_PARMS; i++) {
+        for (i = 1; i < SI_MAX_PARMS; i++) {
                 rv = init_one_smi(i, &(smi_infos[pos]));
                 if (rv == 0)
                         pos++;
@@ -2361,14 +2376,14 @@ static void __exit cleanup_one_si(struct smi_info *to_clean)
 
         /* Wait for the timer to stop.  This avoids problems with race
            conditions removing the timer here. */
-        while (!to_clean->timer_stopped) {
+        while (! to_clean->timer_stopped) {
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 schedule_timeout(1);
         }
 
         /* Interrupts and timeouts are stopped, now make sure the
            interface is in a clean state. */
-        while ((to_clean->curr_msg) || (to_clean->si_state != SI_NORMAL)) {
+        while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
                 poll(to_clean);
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 schedule_timeout(1);
@@ -2392,13 +2407,15 @@ static __exit void cleanup_ipmi_si(void)
 {
         int i;
 
-        if (!initialized)
+        if (! initialized)
                 return;
 
-        for (i=0; i<SI_MAX_DRIVERS; i++) {
+        for (i = 0; i < SI_MAX_DRIVERS; i++) {
                 cleanup_one_si(smi_infos[i]);
         }
 }
 module_exit(cleanup_ipmi_si);
 
 MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
+MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");
diff --git a/drivers/char/ipmi/ipmi_smic_sm.c b/drivers/char/ipmi/ipmi_smic_sm.c
index ae18747e670b..add2aa2732f0 100644
--- a/drivers/char/ipmi/ipmi_smic_sm.c
+++ b/drivers/char/ipmi/ipmi_smic_sm.c
@@ -46,8 +46,6 @@
 #include <linux/ipmi_msgdefs.h>         /* for completion codes */
 #include "ipmi_si_sm.h"
 
-#define IPMI_SMIC_VERSION "v33"
-
 /* smic_debug is a bit-field
  *      SMIC_DEBUG_ENABLE -     turned on for now
  *      SMIC_DEBUG_MSG -        commands and their responses
@@ -588,7 +586,6 @@ static int smic_size(void)
 
 struct si_sm_handlers smic_smi_handlers =
 {
-        .version           = IPMI_SMIC_VERSION,
         .init_data         = init_smic_data,
         .start_transaction = start_smic_transaction,
         .get_result        = smic_get_result,
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index d35a953961cb..e71aaae855ad 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -53,8 +53,6 @@
 
 #define PFX "IPMI Watchdog: "
 
-#define IPMI_WATCHDOG_VERSION "v33"
-
 /*
  * The IPMI command/response information for the watchdog timer.
  */
@@ -259,7 +257,7 @@ static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
 
         data[1] = 0;
         WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
-        if (pretimeout > 0) {
+        if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
             WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
             data[2] = pretimeout;
         } else {
@@ -659,19 +657,18 @@ static ssize_t ipmi_read(struct file *file,
 
 static int ipmi_open(struct inode *ino, struct file *filep)
 {
-        switch (iminor(ino))
-        {
-                case WATCHDOG_MINOR:
-                    if(test_and_set_bit(0, &ipmi_wdog_open))
+        switch (iminor(ino)) {
+        case WATCHDOG_MINOR:
+                if (test_and_set_bit(0, &ipmi_wdog_open))
                         return -EBUSY;
 
-                    /* Don't start the timer now, let it start on the
-                       first heartbeat. */
-                    ipmi_start_timer_on_heartbeat = 1;
-                    return nonseekable_open(ino, filep);
+                /* Don't start the timer now, let it start on the
+                   first heartbeat. */
+                ipmi_start_timer_on_heartbeat = 1;
+                return nonseekable_open(ino, filep);
 
-                default:
-                    return (-ENODEV);
+        default:
+                return (-ENODEV);
         }
 }
 
@@ -817,15 +814,19 @@ static void ipmi_register_watchdog(int ipmi_intf)
 static int
 ipmi_nmi(void *dev_id, struct pt_regs *regs, int cpu, int handled)
 {
+        /* If we are not expecting a timeout, ignore it. */
+        if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
+                return NOTIFY_DONE;
+
         /* If no one else handled the NMI, we assume it was the IPMI
            watchdog. */
-        if ((!handled) && (preop_val == WDOG_PREOP_PANIC))
+        if ((!handled) && (preop_val == WDOG_PREOP_PANIC)) {
+                /* On some machines, the heartbeat will give
+                   an error and not work unless we re-enable
+                   the timer.   So do so. */
+                pretimeout_since_last_heartbeat = 1;
                 panic(PFX "pre-timeout");
-
-        /* On some machines, the heartbeat will give
-           an error and not work unless we re-enable
-           the timer.   So do so. */
-        pretimeout_since_last_heartbeat = 1;
+        }
 
         return NOTIFY_DONE;
 }
@@ -924,9 +925,6 @@ static int __init ipmi_wdog_init(void)
 {
         int rv;
 
-        printk(KERN_INFO PFX "driver version "
-               IPMI_WATCHDOG_VERSION "\n");
-
         if (strcmp(action, "reset") == 0) {
                 action_val = WDOG_TIMEOUT_RESET;
         } else if (strcmp(action, "none") == 0) {
@@ -1011,6 +1009,8 @@ static int __init ipmi_wdog_init(void)
         register_reboot_notifier(&wdog_reboot_notifier);
         notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier);
 
+        printk(KERN_INFO PFX "driver initialized\n");
+
         return 0;
 }
 
@@ -1062,3 +1062,5 @@ static void __exit ipmi_wdog_exit(void)
 module_exit(ipmi_wdog_exit);
 module_init(ipmi_wdog_init);
 MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
+MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");
diff --git a/drivers/char/mbcs.c b/drivers/char/mbcs.c
index 115dbb35334b..3fa64c631108 100644
--- a/drivers/char/mbcs.c
+++ b/drivers/char/mbcs.c
@@ -750,7 +750,7 @@ static int mbcs_probe(struct cx_dev *dev, const struct cx_device_id *id)
 
         dev->soft = NULL;
 
-        soft = kcalloc(1, sizeof(struct mbcs_soft), GFP_KERNEL);
+        soft = kzalloc(sizeof(struct mbcs_soft), GFP_KERNEL);
         if (soft == NULL)
                 return -ENOMEM;
 
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 850a78c9c4bc..f182752fe918 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -35,10 +35,6 @@
 # include <linux/efi.h>
 #endif
 
-#if defined(CONFIG_S390_TAPE) && defined(CONFIG_S390_TAPE_CHAR)
-extern void tapechar_init(void);
-#endif
-
 /*
  * Architectures vary in how they handle caching for addresses
  * outside of main memory.
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 931efd58f87a..0c8375165e29 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -63,8 +63,6 @@ static DECLARE_MUTEX(misc_sem);
 #define DYNAMIC_MINORS 64 /* like dynamic majors */
 static unsigned char misc_minors[DYNAMIC_MINORS / 8];
 
-extern int rtc_DP8570A_init(void);
-extern int rtc_MK48T08_init(void);
 extern int pmu_device_init(void);
 
 #ifdef CONFIG_PROC_FS
@@ -303,12 +301,7 @@ static int __init misc_init(void)
         misc_class = class_create(THIS_MODULE, "misc");
         if (IS_ERR(misc_class))
                 return PTR_ERR(misc_class);
-#ifdef CONFIG_MVME16x
-        rtc_MK48T08_init();
-#endif
-#ifdef CONFIG_BVME6000
-        rtc_DP8570A_init();
-#endif
+
         if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) {
                 printk("unable to get major %d for misc devices\n",
                        MISC_MAJOR);
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index cefbe985e55c..36ae9ad2598c 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -98,12 +98,13 @@ MODULE_PARM_DESC(useinput,
 
 #define SONYPI_DEVICE_MODEL_TYPE1       1
 #define SONYPI_DEVICE_MODEL_TYPE2       2
+#define SONYPI_DEVICE_MODEL_TYPE3       3
 
 /* type1 models use those */
 #define SONYPI_IRQ_PORT                 0x8034
 #define SONYPI_IRQ_SHIFT                22
-#define SONYPI_BASE                     0x50
-#define SONYPI_G10A                     (SONYPI_BASE+0x14)
+#define SONYPI_TYPE1_BASE               0x50
+#define SONYPI_G10A                     (SONYPI_TYPE1_BASE+0x14)
 #define SONYPI_TYPE1_REGION_SIZE        0x08
 #define SONYPI_TYPE1_EVTYPE_OFFSET      0x04
 
@@ -114,6 +115,13 @@ MODULE_PARM_DESC(useinput,
 #define SONYPI_TYPE2_REGION_SIZE        0x20
 #define SONYPI_TYPE2_EVTYPE_OFFSET      0x12
 
+/* type3 series specifics */
+#define SONYPI_TYPE3_BASE               0x40
+#define SONYPI_TYPE3_GID2               (SONYPI_TYPE3_BASE+0x48) /* 16 bits */
+#define SONYPI_TYPE3_MISC               (SONYPI_TYPE3_BASE+0x6d) /* 8 bits  */
+#define SONYPI_TYPE3_REGION_SIZE        0x20
+#define SONYPI_TYPE3_EVTYPE_OFFSET      0x12
+
 /* battery / brightness addresses */
 #define SONYPI_BAT_FLAGS        0x81
 #define SONYPI_LCD_LIGHT        0x96
@@ -159,6 +167,10 @@ static struct sonypi_ioport_list sonypi_type2_ioport_list[] = {
         { 0x0, 0x0 }
 };
 
+/* same as in type 2 models */
+static struct sonypi_ioport_list *sonypi_type3_ioport_list =
+        sonypi_type2_ioport_list;
+
 /* The set of possible interrupts */
 struct sonypi_irq_list {
         u16     irq;
@@ -180,6 +192,9 @@ static struct sonypi_irq_list sonypi_type2_irq_list[] = {
         {  0, 0x00 }    /* no IRQ, 0x00 in SIRQ in AML */
 };
 
+/* same as in type2 models */
+static struct sonypi_irq_list *sonypi_type3_irq_list = sonypi_type2_irq_list;
+
 #define SONYPI_CAMERA_BRIGHTNESS                0
 #define SONYPI_CAMERA_CONTRAST                  1
 #define SONYPI_CAMERA_HUE                       2
@@ -223,6 +238,7 @@ static struct sonypi_irq_list sonypi_type2_irq_list[] = {
 #define SONYPI_MEYE_MASK                        0x00000400
 #define SONYPI_MEMORYSTICK_MASK                 0x00000800
 #define SONYPI_BATTERY_MASK                     0x00001000
+#define SONYPI_WIRELESS_MASK                    0x00002000
 
 struct sonypi_event {
         u8      data;
@@ -305,6 +321,13 @@ static struct sonypi_event sonypi_blueev[] = {
         { 0, 0 }
 };
 
+/* The set of possible wireless events */
+static struct sonypi_event sonypi_wlessev[] = {
+        { 0x59, SONYPI_EVENT_WIRELESS_ON },
+        { 0x5a, SONYPI_EVENT_WIRELESS_OFF },
+        { 0, 0 }
+};
+
 /* The set of possible back button events */
 static struct sonypi_event sonypi_backev[] = {
         { 0x20, SONYPI_EVENT_BACK_PRESSED },
@@ -383,7 +406,6 @@ static struct sonypi_eventtypes {
         { SONYPI_DEVICE_MODEL_TYPE2, 0x31, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
         { SONYPI_DEVICE_MODEL_TYPE2, 0x08, SONYPI_PKEY_MASK, sonypi_pkeyev },
         { SONYPI_DEVICE_MODEL_TYPE2, 0x11, SONYPI_BACK_MASK, sonypi_backev },
-        { SONYPI_DEVICE_MODEL_TYPE2, 0x08, SONYPI_HELP_MASK, sonypi_helpev },
         { SONYPI_DEVICE_MODEL_TYPE2, 0x21, SONYPI_HELP_MASK, sonypi_helpev },
         { SONYPI_DEVICE_MODEL_TYPE2, 0x21, SONYPI_ZOOM_MASK, sonypi_zoomev },
         { SONYPI_DEVICE_MODEL_TYPE2, 0x20, SONYPI_THUMBPHRASE_MASK, sonypi_thumbphraseev },
@@ -391,6 +413,12 @@ static struct sonypi_eventtypes {
         { SONYPI_DEVICE_MODEL_TYPE2, 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
         { SONYPI_DEVICE_MODEL_TYPE2, 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
 
+        { SONYPI_DEVICE_MODEL_TYPE3, 0, 0xffffffff, sonypi_releaseev },
+        { SONYPI_DEVICE_MODEL_TYPE3, 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
+        { SONYPI_DEVICE_MODEL_TYPE3, 0x31, SONYPI_WIRELESS_MASK, sonypi_wlessev },
+        { SONYPI_DEVICE_MODEL_TYPE3, 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
+        { SONYPI_DEVICE_MODEL_TYPE3, 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
+        { SONYPI_DEVICE_MODEL_TYPE3, 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
         { 0 }
 };
 
@@ -563,6 +591,23 @@ static void sonypi_type2_srs(void)
         udelay(10);
 }
 
+static void sonypi_type3_srs(void)
+{
+        u16 v16;
+        u8  v8;
+
+        /* This model type uses the same initialiazation of
+         * the embedded controller as the type2 models. */
+        sonypi_type2_srs();
+
+        /* Initialization of PCI config space of the LPC interface bridge. */
+        v16 = (sonypi_device.ioport1 & 0xFFF0) | 0x01;
+        pci_write_config_word(sonypi_device.dev, SONYPI_TYPE3_GID2, v16);
+        pci_read_config_byte(sonypi_device.dev, SONYPI_TYPE3_MISC, &v8);
+        v8 = (v8 & 0xCF) | 0x10;
+        pci_write_config_byte(sonypi_device.dev, SONYPI_TYPE3_MISC, v8);
+}
+
 /* Disables the device - this comes from the AML code in the ACPI bios */
 static void sonypi_type1_dis(void)
 {
@@ -587,6 +632,13 @@ static void sonypi_type2_dis(void)
                 printk(KERN_WARNING "ec_write failed\n");
 }
 
+static void sonypi_type3_dis(void)
+{
+        sonypi_type2_dis();
+        udelay(10);
+        pci_write_config_word(sonypi_device.dev, SONYPI_TYPE3_GID2, 0);
+}
+
 static u8 sonypi_call1(u8 dev)
 {
         u8 v1, v2;
@@ -1067,10 +1119,17 @@ static struct miscdevice sonypi_misc_device = {
 
 static void sonypi_enable(unsigned int camera_on)
 {
-        if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2)
-                sonypi_type2_srs();
-        else
+        switch (sonypi_device.model) {
+        case SONYPI_DEVICE_MODEL_TYPE1:
                 sonypi_type1_srs();
+                break;
+        case SONYPI_DEVICE_MODEL_TYPE2:
+                sonypi_type2_srs();
+                break;
+        case SONYPI_DEVICE_MODEL_TYPE3:
+                sonypi_type3_srs();
+                break;
+        }
 
         sonypi_call1(0x82);
         sonypi_call2(0x81, 0xff);
@@ -1094,10 +1153,18 @@ static int sonypi_disable(void)
         if (!SONYPI_ACPI_ACTIVE && fnkeyinit)
                 outb(0xf1, 0xb2);
 
-        if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2)
-                sonypi_type2_dis();
-        else
+        switch (sonypi_device.model) {
+        case SONYPI_DEVICE_MODEL_TYPE1:
                 sonypi_type1_dis();
+                break;
+        case SONYPI_DEVICE_MODEL_TYPE2:
+                sonypi_type2_dis();
+                break;
+        case SONYPI_DEVICE_MODEL_TYPE3:
+                sonypi_type3_dis();
+                break;
+        }
+
         return 0;
 }
 
@@ -1143,12 +1210,16 @@ static int __devinit sonypi_probe(void)
         struct sonypi_irq_list *irq_list;
         struct pci_dev *pcidev;
 
-        pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
-                                PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
+        if ((pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                     PCI_DEVICE_ID_INTEL_82371AB_3, NULL)))
+                sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE1;
+        else if ((pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                          PCI_DEVICE_ID_INTEL_ICH6_1, NULL)))
+                sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE3;
+        else
+                sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE2;
 
         sonypi_device.dev = pcidev;
-        sonypi_device.model = pcidev ?
-                SONYPI_DEVICE_MODEL_TYPE1 : SONYPI_DEVICE_MODEL_TYPE2;
 
         spin_lock_init(&sonypi_device.fifo_lock);
         sonypi_device.fifo = kfifo_alloc(SONYPI_BUF_SIZE, GFP_KERNEL,
@@ -1176,16 +1247,22 @@ static int __devinit sonypi_probe(void)
                 goto out_miscreg;
         }
 
-        if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
+
+        if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE1) {
+                ioport_list = sonypi_type1_ioport_list;
+                sonypi_device.region_size = SONYPI_TYPE1_REGION_SIZE;
+                sonypi_device.evtype_offset = SONYPI_TYPE1_EVTYPE_OFFSET;
+                irq_list = sonypi_type1_irq_list;
+        } else if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
                 ioport_list = sonypi_type2_ioport_list;
                 sonypi_device.region_size = SONYPI_TYPE2_REGION_SIZE;
                 sonypi_device.evtype_offset = SONYPI_TYPE2_EVTYPE_OFFSET;
                 irq_list = sonypi_type2_irq_list;
         } else {
-                ioport_list = sonypi_type1_ioport_list;
-                sonypi_device.region_size = SONYPI_TYPE1_REGION_SIZE;
-                sonypi_device.evtype_offset = SONYPI_TYPE1_EVTYPE_OFFSET;
-                irq_list = sonypi_type1_irq_list;
+                ioport_list = sonypi_type3_ioport_list;
+                sonypi_device.region_size = SONYPI_TYPE3_REGION_SIZE;
+                sonypi_device.evtype_offset = SONYPI_TYPE3_EVTYPE_OFFSET;
+                irq_list = sonypi_type3_irq_list;
         }
 
         for (i = 0; ioport_list[i].port1; i++) {
@@ -1274,11 +1351,10 @@ static int __devinit sonypi_probe(void)
 
         printk(KERN_INFO "sonypi: Sony Programmable I/O Controller Driver"
                "v%s.\n", SONYPI_DRIVER_VERSION);
-        printk(KERN_INFO "sonypi: detected %s model, "
+        printk(KERN_INFO "sonypi: detected type%d model, "
                "verbose = %d, fnkeyinit = %s, camera = %s, "
                "compat = %s, mask = 0x%08lx, useinput = %s, acpi = %s\n",
-               (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE1) ?
-                        "type1" : "type2",
+               sonypi_device.model,
                verbose,
                fnkeyinit ? "on" : "off",
                camera ? "on" : "off",
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index cc2cc77fd174..c0d64914595f 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -206,6 +206,9 @@ static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
         {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
         {PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6LPC)},
         {0,}
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 6e4be3bb2d89..9d657127f313 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -153,7 +153,6 @@ static int tty_release(struct inode *, struct file *);
 int tty_ioctl(struct inode * inode, struct file * file,
               unsigned int cmd, unsigned long arg);
 static int tty_fasync(int fd, struct file * filp, int on);
-extern void rs_360_init(void);
 static void release_mem(struct tty_struct *tty, int idx);
 
 
@@ -2911,11 +2910,6 @@ void __init console_init(void)
 #ifdef CONFIG_EARLY_PRINTK
         disable_early_printk();
 #endif
-#ifdef CONFIG_SERIAL_68360
-        /* This is not a console initcall. I know not what it's doing here.
-           So I haven't moved it. dwmw2 */
-        rs_360_init();
-#endif
         call = __con_initcall_start;
         while (call < __con_initcall_end) {
                 (*call)();
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 665103ccaee8..b8d0c290b0db 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -434,21 +434,25 @@ void invert_screen(struct vc_data *vc, int offset, int count, int viewed)
 /* used by selection: complement pointer position */
 void complement_pos(struct vc_data *vc, int offset)
 {
-        static unsigned short *p;
+        static int old_offset = -1;
         static unsigned short old;
         static unsigned short oldx, oldy;
 
         WARN_CONSOLE_UNLOCKED();
 
-        if (p) {
-                scr_writew(old, p);
+        if (old_offset != -1 && old_offset >= 0 &&
+            old_offset < vc->vc_screenbuf_size) {
+                scr_writew(old, screenpos(vc, old_offset, 1));
                 if (DO_UPDATE(vc))
                         vc->vc_sw->con_putc(vc, old, oldy, oldx);
         }
-        if (offset == -1)
-                p = NULL;
-        else {
+
+        old_offset = offset;
+
+        if (offset != -1 && offset >= 0 &&
+            offset < vc->vc_screenbuf_size) {
                 unsigned short new;
+                unsigned short *p;
                 p = screenpos(vc, offset, 1);
                 old = scr_readw(p);
                 new = old ^ vc->vc_complement_mask;
@@ -459,6 +463,7 @@ void complement_pos(struct vc_data *vc, int offset)
                         vc->vc_sw->con_putc(vc, new, oldy, oldx);
                 }
         }
+
 }
 
 static void insert_char(struct vc_data *vc, unsigned int nr)
@@ -2272,7 +2277,9 @@ int tioclinux(struct tty_struct *tty, unsigned long arg)
                         ret = paste_selection(tty);
                         break;
                 case TIOCL_UNBLANKSCREEN:
+                        acquire_console_sem();
                         unblank_screen();
+                        release_console_sem();
                         break;
                 case TIOCL_SELLOADLUT:
                         ret = sel_loadlut(p);
@@ -2317,8 +2324,10 @@ int tioclinux(struct tty_struct *tty, unsigned long arg)
                         }
                         break;
                 case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */
+                        acquire_console_sem();
                         ignore_poke = 1;
                         do_blank_screen(0);
+                        release_console_sem();
                         break;
                 case TIOCL_BLANKEDSCREEN:
                         ret = console_blanked;
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 5b29c3b2a331..327b58e64875 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -58,4 +58,31 @@ config EFI_PCDP
 
           See <http://www.dig64.org/specifications/DIG64_HCDPv20_042804.pdf>
 
+config DELL_RBU
+        tristate "BIOS update support for DELL systems via sysfs"
+        select FW_LOADER
+        help
+         Say m if you want to have the option of updating the BIOS for your
+         DELL system. Note you need a Dell OpenManage or Dell Update package (DUP)
+         supporting application to comunicate with the BIOS regarding the new
+         image for the image update to take effect.
+         See <file:Documentation/dell_rbu.txt> for more details on the driver.
+
+config DCDBAS
+        tristate "Dell Systems Management Base Driver"
+        depends on X86 || X86_64
+        default m
+        help
+          The Dell Systems Management Base Driver provides a sysfs interface
+          for systems management software to perform System Management
+          Interrupts (SMIs) and Host Control Actions (system power cycle or
+          power off after OS shutdown) on certain Dell systems.
+
+          See <file:Documentation/dcdbas.txt> for more details on the driver
+          and the Dell systems on which Dell systems management software makes
+          use of this driver.
+
+          Say Y or M here to enable the driver for use by Dell systems
+          management software such as Dell OpenManage.
+
 endmenu
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 90fd0b26db8b..85429979d0db 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -4,3 +4,5 @@
 obj-$(CONFIG_EDD)               += edd.o
 obj-$(CONFIG_EFI_VARS)          += efivars.o
 obj-$(CONFIG_EFI_PCDP)          += pcdp.o
+obj-$(CONFIG_DELL_RBU)          += dell_rbu.o
+obj-$(CONFIG_DCDBAS)            += dcdbas.o
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
new file mode 100644
index 000000000000..955537fe9958
--- /dev/null
+++ b/drivers/firmware/dcdbas.c
@@ -0,0 +1,596 @@
+/*
+ *  dcdbas.c: Dell Systems Management Base Driver
+ *
+ *  The Dell Systems Management Base Driver provides a sysfs interface for
+ *  systems management software to perform System Management Interrupts (SMIs)
+ *  and Host Control Actions (power cycle or power off after OS shutdown) on
+ *  Dell systems.
+ *
+ *  See Documentation/dcdbas.txt for more information.
+ *
+ *  Copyright (C) 1995-2005 Dell Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License v2.0 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.
+ */
+
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/mc146818rtc.h>
+#include <linux/module.h>
+#include <linux/reboot.h>
+#include <linux/sched.h>
+#include <linux/smp.h>
+#include <linux/spinlock.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <asm/io.h>
+#include <asm/semaphore.h>
+
+#include "dcdbas.h"
+
+#define DRIVER_NAME             "dcdbas"
+#define DRIVER_VERSION          "5.6.0-1"
+#define DRIVER_DESCRIPTION      "Dell Systems Management Base Driver"
+
+static struct platform_device *dcdbas_pdev;
+
+static u8 *smi_data_buf;
+static dma_addr_t smi_data_buf_handle;
+static unsigned long smi_data_buf_size;
+static u32 smi_data_buf_phys_addr;
+static DECLARE_MUTEX(smi_data_lock);
+
+static unsigned int host_control_action;
+static unsigned int host_control_smi_type;
+static unsigned int host_control_on_shutdown;
+
+/**
+ * smi_data_buf_free: free SMI data buffer
+ */
+static void smi_data_buf_free(void)
+{
+        if (!smi_data_buf)
+                return;
+
+        dev_dbg(&dcdbas_pdev->dev, "%s: phys: %x size: %lu\n",
+                __FUNCTION__, smi_data_buf_phys_addr, smi_data_buf_size);
+
+        dma_free_coherent(&dcdbas_pdev->dev, smi_data_buf_size, smi_data_buf,
+                          smi_data_buf_handle);
+        smi_data_buf = NULL;
+        smi_data_buf_handle = 0;
+        smi_data_buf_phys_addr = 0;
+        smi_data_buf_size = 0;
+}
+
+/**
+ * smi_data_buf_realloc: grow SMI data buffer if needed
+ */
+static int smi_data_buf_realloc(unsigned long size)
+{
+        void *buf;
+        dma_addr_t handle;
+
+        if (smi_data_buf_size >= size)
+                return 0;
+
+        if (size > MAX_SMI_DATA_BUF_SIZE)
+                return -EINVAL;
+
+        /* new buffer is needed */
+        buf = dma_alloc_coherent(&dcdbas_pdev->dev, size, &handle, GFP_KERNEL);
+        if (!buf) {
+                dev_dbg(&dcdbas_pdev->dev,
+                        "%s: failed to allocate memory size %lu\n",
+                        __FUNCTION__, size);
+                return -ENOMEM;
+        }
+        /* memory zeroed by dma_alloc_coherent */
+
+        if (smi_data_buf)
+                memcpy(buf, smi_data_buf, smi_data_buf_size);
+
+        /* free any existing buffer */
+        smi_data_buf_free();
+
+        /* set up new buffer for use */
+        smi_data_buf = buf;
+        smi_data_buf_handle = handle;
+        smi_data_buf_phys_addr = (u32) virt_to_phys(buf);
+        smi_data_buf_size = size;
+
+        dev_dbg(&dcdbas_pdev->dev, "%s: phys: %x size: %lu\n",
+                __FUNCTION__, smi_data_buf_phys_addr, smi_data_buf_size);
+
+        return 0;
+}
+
+static ssize_t smi_data_buf_phys_addr_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        return sprintf(buf, "%x\n", smi_data_buf_phys_addr);
+}
+
+static ssize_t smi_data_buf_size_show(struct device *dev,
+                                      struct device_attribute *attr,
+                                      char *buf)
+{
+        return sprintf(buf, "%lu\n", smi_data_buf_size);
+}
+
+static ssize_t smi_data_buf_size_store(struct device *dev,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
+{
+        unsigned long buf_size;
+        ssize_t ret;
+
+        buf_size = simple_strtoul(buf, NULL, 10);
+
+        /* make sure SMI data buffer is at least buf_size */
+        down(&smi_data_lock);
+        ret = smi_data_buf_realloc(buf_size);
+        up(&smi_data_lock);
+        if (ret)
+                return ret;
+
+        return count;
+}
+
+static ssize_t smi_data_read(struct kobject *kobj, char *buf, loff_t pos,
+                             size_t count)
+{
+        size_t max_read;
+        ssize_t ret;
+
+        down(&smi_data_lock);
+
+        if (pos >= smi_data_buf_size) {
+                ret = 0;
+                goto out;
+        }
+
+        max_read = smi_data_buf_size - pos;
+        ret = min(max_read, count);
+        memcpy(buf, smi_data_buf + pos, ret);
+out:
+        up(&smi_data_lock);
+        return ret;
+}
+
+static ssize_t smi_data_write(struct kobject *kobj, char *buf, loff_t pos,
+                              size_t count)
+{
+        ssize_t ret;
+
+        down(&smi_data_lock);
+
+        ret = smi_data_buf_realloc(pos + count);
+        if (ret)
+                goto out;
+
+        memcpy(smi_data_buf + pos, buf, count);
+        ret = count;
+out:
+        up(&smi_data_lock);
+        return ret;
+}
+
+static ssize_t host_control_action_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        return sprintf(buf, "%u\n", host_control_action);
+}
+
+static ssize_t host_control_action_store(struct device *dev,
+                                         struct device_attribute *attr,
+                                         const char *buf, size_t count)
+{
+        ssize_t ret;
+
+        /* make sure buffer is available for host control command */
+        down(&smi_data_lock);
+        ret = smi_data_buf_realloc(sizeof(struct apm_cmd));
+        up(&smi_data_lock);
+        if (ret)
+                return ret;
+
+        host_control_action = simple_strtoul(buf, NULL, 10);
+        return count;
+}
+
+static ssize_t host_control_smi_type_show(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *buf)
+{
+        return sprintf(buf, "%u\n", host_control_smi_type);
+}
+
+static ssize_t host_control_smi_type_store(struct device *dev,
+                                           struct device_attribute *attr,
+                                           const char *buf, size_t count)
+{
+        host_control_smi_type = simple_strtoul(buf, NULL, 10);
+        return count;
+}
+
+static ssize_t host_control_on_shutdown_show(struct device *dev,
+                                             struct device_attribute *attr,
+                                             char *buf)
+{
+        return sprintf(buf, "%u\n", host_control_on_shutdown);
+}
+
+static ssize_t host_control_on_shutdown_store(struct device *dev,
+                                              struct device_attribute *attr,
+                                              const char *buf, size_t count)
+{
+        host_control_on_shutdown = simple_strtoul(buf, NULL, 10);
+        return count;
+}
+
+/**
+ * smi_request: generate SMI request
+ *
+ * Called with smi_data_lock.
+ */
+static int smi_request(struct smi_cmd *smi_cmd)
+{
+        cpumask_t old_mask;
+        int ret = 0;
+
+        if (smi_cmd->magic != SMI_CMD_MAGIC) {
+                dev_info(&dcdbas_pdev->dev, "%s: invalid magic value\n",
+                         __FUNCTION__);
+                return -EBADR;
+        }
+
+        /* SMI requires CPU 0 */
+        old_mask = current->cpus_allowed;
+        set_cpus_allowed(current, cpumask_of_cpu(0));
+        if (smp_processor_id() != 0) {
+                dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
+                        __FUNCTION__);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        /* generate SMI */
+        asm volatile (
+                "outb %b0,%w1"
+                : /* no output args */
+                : "a" (smi_cmd->command_code),
+                  "d" (smi_cmd->command_address),
+                  "b" (smi_cmd->ebx),
+                  "c" (smi_cmd->ecx)
+                : "memory"
+        );
+
+out:
+        set_cpus_allowed(current, old_mask);
+        return ret;
+}
+
+/**
+ * smi_request_store:
+ *
+ * The valid values are:
+ * 0: zero SMI data buffer
+ * 1: generate calling interface SMI
+ * 2: generate raw SMI
+ *
+ * User application writes smi_cmd to smi_data before telling driver
+ * to generate SMI.
+ */
+static ssize_t smi_request_store(struct device *dev,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t count)
+{
+        struct smi_cmd *smi_cmd;
+        unsigned long val = simple_strtoul(buf, NULL, 10);
+        ssize_t ret;
+
+        down(&smi_data_lock);
+
+        if (smi_data_buf_size < sizeof(struct smi_cmd)) {
+                ret = -ENODEV;
+                goto out;
+        }
+        smi_cmd = (struct smi_cmd *)smi_data_buf;
+
+        switch (val) {
+        case 2:
+                /* Raw SMI */
+                ret = smi_request(smi_cmd);
+                if (!ret)
+                        ret = count;
+                break;
+        case 1:
+                /* Calling Interface SMI */
+                smi_cmd->ebx = (u32) virt_to_phys(smi_cmd->command_buffer);
+                ret = smi_request(smi_cmd);
+                if (!ret)
+                        ret = count;
+                break;
+        case 0:
+                memset(smi_data_buf, 0, smi_data_buf_size);
+                ret = count;
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+out:
+        up(&smi_data_lock);
+        return ret;
+}
+
+/**
+ * host_control_smi: generate host control SMI
+ *
+ * Caller must set up the host control command in smi_data_buf.
+ */
+static int host_control_smi(void)
+{
+        struct apm_cmd *apm_cmd;
+        u8 *data;
+        unsigned long flags;
+        u32 num_ticks;
+        s8 cmd_status;
+        u8 index;
+
+        apm_cmd = (struct apm_cmd *)smi_data_buf;
+        apm_cmd->status = ESM_STATUS_CMD_UNSUCCESSFUL;
+
+        switch (host_control_smi_type) {
+        case HC_SMITYPE_TYPE1:
+                spin_lock_irqsave(&rtc_lock, flags);
+                /* write SMI data buffer physical address */
+                data = (u8 *)&smi_data_buf_phys_addr;
+                for (index = PE1300_CMOS_CMD_STRUCT_PTR;
+                     index < (PE1300_CMOS_CMD_STRUCT_PTR + 4);
+                     index++, data++) {
+                        outb(index,
+                             (CMOS_BASE_PORT + CMOS_PAGE2_INDEX_PORT_PIIX4));
+                        outb(*data,
+                             (CMOS_BASE_PORT + CMOS_PAGE2_DATA_PORT_PIIX4));
+                }
+
+                /* first set status to -1 as called by spec */
+                cmd_status = ESM_STATUS_CMD_UNSUCCESSFUL;
+                outb((u8) cmd_status, PCAT_APM_STATUS_PORT);
+
+                /* generate SMM call */
+                outb(ESM_APM_CMD, PCAT_APM_CONTROL_PORT);
+                spin_unlock_irqrestore(&rtc_lock, flags);
+
+                /* wait a few to see if it executed */
+                num_ticks = TIMEOUT_USEC_SHORT_SEMA_BLOCKING;
+                while ((cmd_status = inb(PCAT_APM_STATUS_PORT))
+                       == ESM_STATUS_CMD_UNSUCCESSFUL) {
+                        num_ticks--;
+                        if (num_ticks == EXPIRED_TIMER)
+                                return -ETIME;
+                }
+                break;
+
+        case HC_SMITYPE_TYPE2:
+        case HC_SMITYPE_TYPE3:
+                spin_lock_irqsave(&rtc_lock, flags);
+                /* write SMI data buffer physical address */
+                data = (u8 *)&smi_data_buf_phys_addr;
+                for (index = PE1400_CMOS_CMD_STRUCT_PTR;
+                     index < (PE1400_CMOS_CMD_STRUCT_PTR + 4);
+                     index++, data++) {
+                        outb(index, (CMOS_BASE_PORT + CMOS_PAGE1_INDEX_PORT));
+                        outb(*data, (CMOS_BASE_PORT + CMOS_PAGE1_DATA_PORT));
+                }
+
+                /* generate SMM call */
+                if (host_control_smi_type == HC_SMITYPE_TYPE3)
+                        outb(ESM_APM_CMD, PCAT_APM_CONTROL_PORT);
+                else
+                        outb(ESM_APM_CMD, PE1400_APM_CONTROL_PORT);
+
+                /* restore RTC index pointer since it was written to above */
+                CMOS_READ(RTC_REG_C);
+                spin_unlock_irqrestore(&rtc_lock, flags);
+
+                /* read control port back to serialize write */
+                cmd_status = inb(PE1400_APM_CONTROL_PORT);
+
+                /* wait a few to see if it executed */
+                num_ticks = TIMEOUT_USEC_SHORT_SEMA_BLOCKING;
+                while (apm_cmd->status == ESM_STATUS_CMD_UNSUCCESSFUL) {
+                        num_ticks--;
+                        if (num_ticks == EXPIRED_TIMER)
+                                return -ETIME;
+                }
+                break;
+
+        default:
+                dev_dbg(&dcdbas_pdev->dev, "%s: invalid SMI type %u\n",
+                        __FUNCTION__, host_control_smi_type);
+                return -ENOSYS;
+        }
+
+        return 0;
+}
+
+/**
+ * dcdbas_host_control: initiate host control
+ *
+ * This function is called by the driver after the system has
+ * finished shutting down if the user application specified a
+ * host control action to perform on shutdown.  It is safe to
+ * use smi_data_buf at this point because the system has finished
+ * shutting down and no userspace apps are running.
+ */
+static void dcdbas_host_control(void)
+{
+        struct apm_cmd *apm_cmd;
+        u8 action;
+
+        if (host_control_action == HC_ACTION_NONE)
+                return;
+
+        action = host_control_action;
+        host_control_action = HC_ACTION_NONE;
+
+        if (!smi_data_buf) {
+                dev_dbg(&dcdbas_pdev->dev, "%s: no SMI buffer\n", __FUNCTION__);
+                return;
+        }
+
+        if (smi_data_buf_size < sizeof(struct apm_cmd)) {
+                dev_dbg(&dcdbas_pdev->dev, "%s: SMI buffer too small\n",
+                        __FUNCTION__);
+                return;
+        }
+
+        apm_cmd = (struct apm_cmd *)smi_data_buf;
+
+        /* power off takes precedence */
+        if (action & HC_ACTION_HOST_CONTROL_POWEROFF) {
+                apm_cmd->command = ESM_APM_POWER_CYCLE;
+                apm_cmd->reserved = 0;
+                *((s16 *)&apm_cmd->parameters.shortreq.parm[0]) = (s16) 0;
+                host_control_smi();
+        } else if (action & HC_ACTION_HOST_CONTROL_POWERCYCLE) {
+                apm_cmd->command = ESM_APM_POWER_CYCLE;
+                apm_cmd->reserved = 0;
+                *((s16 *)&apm_cmd->parameters.shortreq.parm[0]) = (s16) 20;
+                host_control_smi();
+        }
+}
+
+/**
+ * dcdbas_reboot_notify: handle reboot notification for host control
+ */
+static int dcdbas_reboot_notify(struct notifier_block *nb, unsigned long code,
+                                void *unused)
+{
+        static unsigned int notify_cnt = 0;
+
+        switch (code) {
+        case SYS_DOWN:
+        case SYS_HALT:
+        case SYS_POWER_OFF:
+                if (host_control_on_shutdown) {
+                        /* firmware is going to perform host control action */
+                        if (++notify_cnt == 2) {
+                                printk(KERN_WARNING
+                                       "Please wait for shutdown "
+                                       "action to complete...\n");
+                                dcdbas_host_control();
+                        }
+                        /*
+                         * register again and initiate the host control
+                         * action on the second notification to allow
+                         * everyone that registered to be notified
+                         */
+                        register_reboot_notifier(nb);
+                }
+                break;
+        }
+
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block dcdbas_reboot_nb = {
+        .notifier_call = dcdbas_reboot_notify,
+        .next = NULL,
+        .priority = 0
+};
+
+static DCDBAS_BIN_ATTR_RW(smi_data);
+
+static struct bin_attribute *dcdbas_bin_attrs[] = {
+        &bin_attr_smi_data,
+        NULL
+};
+
+static DCDBAS_DEV_ATTR_RW(smi_data_buf_size);
+static DCDBAS_DEV_ATTR_RO(smi_data_buf_phys_addr);
+static DCDBAS_DEV_ATTR_WO(smi_request);
+static DCDBAS_DEV_ATTR_RW(host_control_action);
+static DCDBAS_DEV_ATTR_RW(host_control_smi_type);
+static DCDBAS_DEV_ATTR_RW(host_control_on_shutdown);
+
+static struct device_attribute *dcdbas_dev_attrs[] = {
+        &dev_attr_smi_data_buf_size,
+        &dev_attr_smi_data_buf_phys_addr,
+        &dev_attr_smi_request,
+        &dev_attr_host_control_action,
+        &dev_attr_host_control_smi_type,
+        &dev_attr_host_control_on_shutdown,
+        NULL
+};
+
+/**
+ * dcdbas_init: initialize driver
+ */
+static int __init dcdbas_init(void)
+{
+        int i;
+
+        host_control_action = HC_ACTION_NONE;
+        host_control_smi_type = HC_SMITYPE_NONE;
+
+        dcdbas_pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
+        if (IS_ERR(dcdbas_pdev))
+                return PTR_ERR(dcdbas_pdev);
+
+        /*
+         * BIOS SMI calls require buffer addresses be in 32-bit address space.
+         * This is done by setting the DMA mask below.
+         */
+        dcdbas_pdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
+        dcdbas_pdev->dev.dma_mask = &dcdbas_pdev->dev.coherent_dma_mask;
+
+        register_reboot_notifier(&dcdbas_reboot_nb);
+
+        for (i = 0; dcdbas_bin_attrs[i]; i++)
+                sysfs_create_bin_file(&dcdbas_pdev->dev.kobj,
+                                      dcdbas_bin_attrs[i]);
+
+        for (i = 0; dcdbas_dev_attrs[i]; i++)
+                device_create_file(&dcdbas_pdev->dev, dcdbas_dev_attrs[i]);
+
+        dev_info(&dcdbas_pdev->dev, "%s (version %s)\n",
+                 DRIVER_DESCRIPTION, DRIVER_VERSION);
+
+        return 0;
+}
+
+/**
+ * dcdbas_exit: perform driver cleanup
+ */
+static void __exit dcdbas_exit(void)
+{
+        platform_device_unregister(dcdbas_pdev);
+        unregister_reboot_notifier(&dcdbas_reboot_nb);
+        smi_data_buf_free();
+}
+
+module_init(dcdbas_init);
+module_exit(dcdbas_exit);
+
+MODULE_DESCRIPTION(DRIVER_DESCRIPTION " (version " DRIVER_VERSION ")");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_AUTHOR("Dell Inc.");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/firmware/dcdbas.h b/drivers/firmware/dcdbas.h
new file mode 100644
index 000000000000..58a85182b3e8
--- /dev/null
+++ b/drivers/firmware/dcdbas.h
@@ -0,0 +1,107 @@
+/*
+ *  dcdbas.h: Definitions for Dell Systems Management Base driver
+ *
+ *  Copyright (C) 1995-2005 Dell Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License v2.0 as published by
+ *  the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ */
+
+#ifndef _DCDBAS_H_
+#define _DCDBAS_H_
+
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/sysfs.h>
+#include <linux/types.h>
+
+#define MAX_SMI_DATA_BUF_SIZE                   (256 * 1024)
+
+#define HC_ACTION_NONE                          (0)
+#define HC_ACTION_HOST_CONTROL_POWEROFF         BIT(1)
+#define HC_ACTION_HOST_CONTROL_POWERCYCLE       BIT(2)
+
+#define HC_SMITYPE_NONE                         (0)
+#define HC_SMITYPE_TYPE1                        (1)
+#define HC_SMITYPE_TYPE2                        (2)
+#define HC_SMITYPE_TYPE3                        (3)
+
+#define ESM_APM_CMD                             (0x0A0)
+#define ESM_APM_POWER_CYCLE                     (0x10)
+#define ESM_STATUS_CMD_UNSUCCESSFUL             (-1)
+
+#define CMOS_BASE_PORT                          (0x070)
+#define CMOS_PAGE1_INDEX_PORT                   (0)
+#define CMOS_PAGE1_DATA_PORT                    (1)
+#define CMOS_PAGE2_INDEX_PORT_PIIX4             (2)
+#define CMOS_PAGE2_DATA_PORT_PIIX4              (3)
+#define PE1400_APM_CONTROL_PORT                 (0x0B0)
+#define PCAT_APM_CONTROL_PORT                   (0x0B2)
+#define PCAT_APM_STATUS_PORT                    (0x0B3)
+#define PE1300_CMOS_CMD_STRUCT_PTR              (0x38)
+#define PE1400_CMOS_CMD_STRUCT_PTR              (0x70)
+
+#define MAX_SYSMGMT_SHORTCMD_PARMBUF_LEN        (14)
+#define MAX_SYSMGMT_LONGCMD_SGENTRY_NUM         (16)
+
+#define TIMEOUT_USEC_SHORT_SEMA_BLOCKING        (10000)
+#define EXPIRED_TIMER                           (0)
+
+#define SMI_CMD_MAGIC                           (0x534D4931)
+
+#define DCDBAS_DEV_ATTR_RW(_name) \
+        DEVICE_ATTR(_name,0600,_name##_show,_name##_store);
+
+#define DCDBAS_DEV_ATTR_RO(_name) \
+        DEVICE_ATTR(_name,0400,_name##_show,NULL);
+
+#define DCDBAS_DEV_ATTR_WO(_name) \
+        DEVICE_ATTR(_name,0200,NULL,_name##_store);
+
+#define DCDBAS_BIN_ATTR_RW(_name) \
+struct bin_attribute bin_attr_##_name = { \
+        .attr =  { .name = __stringify(_name), \
+                   .mode = 0600, \
+                   .owner = THIS_MODULE }, \
+        .read =  _name##_read, \
+        .write = _name##_write, \
+}
+
+struct smi_cmd {
+        __u32 magic;
+        __u32 ebx;
+        __u32 ecx;
+        __u16 command_address;
+        __u8 command_code;
+        __u8 reserved;
+        __u8 command_buffer[1];
+} __attribute__ ((packed));
+
+struct apm_cmd {
+        __u8 command;
+        __s8 status;
+        __u16 reserved;
+        union {
+                struct {
+                        __u8 parm[MAX_SYSMGMT_SHORTCMD_PARMBUF_LEN];
+                } __attribute__ ((packed)) shortreq;
+
+                struct {
+                        __u16 num_sg_entries;
+                        struct {
+                                __u32 size;
+                                __u64 addr;
+                        } __attribute__ ((packed))
+                            sglist[MAX_SYSMGMT_LONGCMD_SGENTRY_NUM];
+                } __attribute__ ((packed)) longreq;
+        } __attribute__ ((packed)) parameters;
+} __attribute__ ((packed));
+
+#endif /* _DCDBAS_H_ */
+
diff --git a/drivers/firmware/dell_rbu.c b/drivers/firmware/dell_rbu.c
new file mode 100644
index 000000000000..3b865f34a095
--- /dev/null
+++ b/drivers/firmware/dell_rbu.c
@@ -0,0 +1,634 @@
+/*
+ * dell_rbu.c
+ * Bios Update driver for Dell systems
+ * Author: Dell Inc
+ *         Abhay Salunke <abhay_salunke@dell.com>
+ *
+ * Copyright (C) 2005 Dell Inc.
+ *
+ * Remote BIOS Update (rbu) driver is used for updating DELL BIOS by
+ * creating entries in the /sys file systems on Linux 2.6 and higher
+ * kernels. The driver supports two mechanism to update the BIOS namely
+ * contiguous and packetized. Both these methods still require having some
+ * application to set the CMOS bit indicating the BIOS to update itself
+ * after a reboot.
+ *
+ * Contiguous method:
+ * This driver writes the incoming data in a monolithic image by allocating
+ * contiguous physical pages large enough to accommodate the incoming BIOS
+ * image size.
+ *
+ * Packetized method:
+ * The driver writes the incoming packet image by allocating a new packet
+ * on every time the packet data is written. This driver requires an
+ * application to break the BIOS image in to fixed sized packet chunks.
+ *
+ * See Documentation/dell_rbu.txt for more info.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2.0 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.
+ */
+#include <linux/version.h>
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/blkdev.h>
+#include <linux/device.h>
+#include <linux/spinlock.h>
+#include <linux/moduleparam.h>
+#include <linux/firmware.h>
+#include <linux/dma-mapping.h>
+
+MODULE_AUTHOR("Abhay Salunke <abhay_salunke@dell.com>");
+MODULE_DESCRIPTION("Driver for updating BIOS image on DELL systems");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1.0");
+
+#define BIOS_SCAN_LIMIT 0xffffffff
+#define MAX_IMAGE_LENGTH 16
+static struct _rbu_data {
+        void *image_update_buffer;
+        unsigned long image_update_buffer_size;
+        unsigned long bios_image_size;
+        int image_update_ordernum;
+        int dma_alloc;
+        spinlock_t lock;
+        unsigned long packet_read_count;
+        unsigned long packet_write_count;
+        unsigned long num_packets;
+        unsigned long packetsize;
+} rbu_data;
+
+static char image_type[MAX_IMAGE_LENGTH] = "mono";
+module_param_string(image_type, image_type, sizeof(image_type), 0);
+MODULE_PARM_DESC(image_type, "BIOS image type. choose- mono or packet");
+
+struct packet_data {
+        struct list_head list;
+        size_t length;
+        void *data;
+        int ordernum;
+};
+
+static struct packet_data packet_data_head;
+
+static struct platform_device *rbu_device;
+static int context;
+static dma_addr_t dell_rbu_dmaaddr;
+
+static void init_packet_head(void)
+{
+        INIT_LIST_HEAD(&packet_data_head.list);
+        rbu_data.packet_write_count = 0;
+        rbu_data.packet_read_count = 0;
+        rbu_data.num_packets = 0;
+        rbu_data.packetsize = 0;
+}
+
+static int fill_last_packet(void *data, size_t length)
+{
+        struct list_head *ptemp_list;
+        struct packet_data *packet = NULL;
+        int packet_count = 0;
+
+        pr_debug("fill_last_packet: entry \n");
+
+        if (!rbu_data.num_packets) {
+                pr_debug("fill_last_packet: num_packets=0\n");
+                return -ENOMEM;
+        }
+
+        packet_count = rbu_data.num_packets;
+
+        ptemp_list = (&packet_data_head.list)->prev;
+
+        packet = list_entry(ptemp_list, struct packet_data, list);
+
+        if ((rbu_data.packet_write_count + length) > rbu_data.packetsize) {
+                pr_debug("dell_rbu:%s: packet size data "
+                         "overrun\n", __FUNCTION__);
+                return -EINVAL;
+        }
+
+        pr_debug("fill_last_packet : buffer = %p\n", packet->data);
+
+        memcpy((packet->data + rbu_data.packet_write_count), data, length);
+
+        if ((rbu_data.packet_write_count + length) == rbu_data.packetsize) {
+                /*
+                 * this was the last data chunk in the packet
+                 * so reinitialize the packet data counter to zero
+                 */
+                rbu_data.packet_write_count = 0;
+        } else
+                rbu_data.packet_write_count += length;
+
+        pr_debug("fill_last_packet: exit \n");
+        return 0;
+}
+
+static int create_packet(size_t length)
+{
+        struct packet_data *newpacket;
+        int ordernum = 0;
+
+        pr_debug("create_packet: entry \n");
+
+        if (!rbu_data.packetsize) {
+                pr_debug("create_packet: packetsize not specified\n");
+                return -EINVAL;
+        }
+
+        newpacket = kmalloc(sizeof(struct packet_data), GFP_KERNEL);
+        if (!newpacket) {
+                printk(KERN_WARNING
+                       "dell_rbu:%s: failed to allocate new "
+                       "packet\n", __FUNCTION__);
+                return -ENOMEM;
+        }
+
+        ordernum = get_order(length);
+        /*
+         * there is no upper limit on memory
+         * address for packetized mechanism
+         */
+        newpacket->data = (unsigned char *)__get_free_pages(GFP_KERNEL,
+                                                            ordernum);
+
+        pr_debug("create_packet: newpacket %p\n", newpacket->data);
+
+        if (!newpacket->data) {
+                printk(KERN_WARNING
+                       "dell_rbu:%s: failed to allocate new "
+                       "packet\n", __FUNCTION__);
+                kfree(newpacket);
+                return -ENOMEM;
+        }
+
+        newpacket->ordernum = ordernum;
+        ++rbu_data.num_packets;
+        /*
+         * initialize the newly created packet headers
+         */
+        INIT_LIST_HEAD(&newpacket->list);
+        list_add_tail(&newpacket->list, &packet_data_head.list);
+        /*
+         * packets have fixed size
+         */
+        newpacket->length = rbu_data.packetsize;
+
+        pr_debug("create_packet: exit \n");
+
+        return 0;
+}
+
+static int packetize_data(void *data, size_t length)
+{
+        int rc = 0;
+
+        if (!rbu_data.packet_write_count) {
+                if ((rc = create_packet(length)))
+                        return rc;
+        }
+        if ((rc = fill_last_packet(data, length)))
+                return rc;
+
+        return rc;
+}
+
+static int
+do_packet_read(char *data, struct list_head *ptemp_list,
+               int length, int bytes_read, int *list_read_count)
+{
+        void *ptemp_buf;
+        struct packet_data *newpacket = NULL;
+        int bytes_copied = 0;
+        int j = 0;
+
+        newpacket = list_entry(ptemp_list, struct packet_data, list);
+        *list_read_count += newpacket->length;
+
+        if (*list_read_count > bytes_read) {
+                /* point to the start of unread data */
+                j = newpacket->length - (*list_read_count - bytes_read);
+                /* point to the offset in the packet buffer */
+                ptemp_buf = (u8 *) newpacket->data + j;
+                /*
+                 * check if there is enough room in
+                 * * the incoming buffer
+                 */
+                if (length > (*list_read_count - bytes_read))
+                        /*
+                         * copy what ever is there in this
+                         * packet and move on
+                         */
+                        bytes_copied = (*list_read_count - bytes_read);
+                else
+                        /* copy the remaining */
+                        bytes_copied = length;
+                memcpy(data, ptemp_buf, bytes_copied);
+        }
+        return bytes_copied;
+}
+
+static int packet_read_list(char *data, size_t * pread_length)
+{
+        struct list_head *ptemp_list;
+        int temp_count = 0;
+        int bytes_copied = 0;
+        int bytes_read = 0;
+        int remaining_bytes = 0;
+        char *pdest = data;
+
+        /* check if we have any packets */
+        if (0 == rbu_data.num_packets)
+                return -ENOMEM;
+
+        remaining_bytes = *pread_length;
+        bytes_read = rbu_data.packet_read_count;
+
+        ptemp_list = (&packet_data_head.list)->next;
+        while (!list_empty(ptemp_list)) {
+                bytes_copied = do_packet_read(pdest, ptemp_list,
+                                              remaining_bytes, bytes_read,
+                                              &temp_count);
+                remaining_bytes -= bytes_copied;
+                bytes_read += bytes_copied;
+                pdest += bytes_copied;
+                /*
+                 * check if we reached end of buffer before reaching the
+                 * last packet
+                 */
+                if (remaining_bytes == 0)
+                        break;
+
+                ptemp_list = ptemp_list->next;
+        }
+        /*finally set the bytes read */
+        *pread_length = bytes_read - rbu_data.packet_read_count;
+        rbu_data.packet_read_count = bytes_read;
+        return 0;
+}
+
+static void packet_empty_list(void)
+{
+        struct list_head *ptemp_list;
+        struct list_head *pnext_list;
+        struct packet_data *newpacket;
+
+        ptemp_list = (&packet_data_head.list)->next;
+        while (!list_empty(ptemp_list)) {
+                newpacket =
+                    list_entry(ptemp_list, struct packet_data, list);
+                pnext_list = ptemp_list->next;
+                list_del(ptemp_list);
+                ptemp_list = pnext_list;
+                /*
+                 * zero out the RBU packet memory before freeing
+                 * to make sure there are no stale RBU packets left in memory
+                 */
+                memset(newpacket->data, 0, rbu_data.packetsize);
+                free_pages((unsigned long)newpacket->data,
+                           newpacket->ordernum);
+                kfree(newpacket);
+        }
+        rbu_data.packet_write_count = 0;
+        rbu_data.packet_read_count = 0;
+        rbu_data.num_packets = 0;
+        rbu_data.packetsize = 0;
+}
+
+/*
+ * img_update_free: Frees the buffer allocated for storing BIOS image
+ * Always called with lock held and returned with lock held
+ */
+static void img_update_free(void)
+{
+        if (!rbu_data.image_update_buffer)
+                return;
+        /*
+         * zero out this buffer before freeing it to get rid of any stale
+         * BIOS image copied in memory.
+         */
+        memset(rbu_data.image_update_buffer, 0,
+               rbu_data.image_update_buffer_size);
+        if (rbu_data.dma_alloc == 1)
+                dma_free_coherent(NULL, rbu_data.bios_image_size,
+                                  rbu_data.image_update_buffer,
+                                  dell_rbu_dmaaddr);
+        else
+                free_pages((unsigned long)rbu_data.image_update_buffer,
+                           rbu_data.image_update_ordernum);
+
+        /*
+         * Re-initialize the rbu_data variables after a free
+         */
+        rbu_data.image_update_ordernum = -1;
+        rbu_data.image_update_buffer = NULL;
+        rbu_data.image_update_buffer_size = 0;
+        rbu_data.bios_image_size = 0;
+        rbu_data.dma_alloc = 0;
+}
+
+/*
+ * img_update_realloc: This function allocates the contiguous pages to
+ * accommodate the requested size of data. The memory address and size
+ * values are stored globally and on every call to this function the new
+ * size is checked to see if more data is required than the existing size.
+ * If true the previous memory is freed and new allocation is done to
+ * accommodate the new size. If the incoming size is less then than the
+ * already allocated size, then that memory is reused. This function is
+ * called with lock held and returns with lock held.
+ */
+static int img_update_realloc(unsigned long size)
+{
+        unsigned char *image_update_buffer = NULL;
+        unsigned long rc;
+        unsigned long img_buf_phys_addr;
+        int ordernum;
+        int dma_alloc = 0;
+
+        /*
+         * check if the buffer of sufficient size has been
+         * already allocated
+         */
+        if (rbu_data.image_update_buffer_size >= size) {
+                /*
+                 * check for corruption
+                 */
+                if ((size != 0) && (rbu_data.image_update_buffer == NULL)) {
+                        printk(KERN_ERR "dell_rbu:%s: corruption "
+                               "check failed\n", __FUNCTION__);
+                        return -EINVAL;
+                }
+                /*
+                 * we have a valid pre-allocated buffer with
+                 * sufficient size
+                 */
+                return 0;
+        }
+
+        /*
+         * free any previously allocated buffer
+         */
+        img_update_free();
+
+        spin_unlock(&rbu_data.lock);
+
+        ordernum = get_order(size);
+        image_update_buffer =
+            (unsigned char *)__get_free_pages(GFP_KERNEL, ordernum);
+
+        img_buf_phys_addr =
+            (unsigned long)virt_to_phys(image_update_buffer);
+
+        if (img_buf_phys_addr > BIOS_SCAN_LIMIT) {
+                free_pages((unsigned long)image_update_buffer, ordernum);
+                ordernum = -1;
+                image_update_buffer = dma_alloc_coherent(NULL, size,
+                                                         &dell_rbu_dmaaddr,
+                                                         GFP_KERNEL);
+                dma_alloc = 1;
+        }
+
+        spin_lock(&rbu_data.lock);
+
+        if (image_update_buffer != NULL) {
+                rbu_data.image_update_buffer = image_update_buffer;
+                rbu_data.image_update_buffer_size = size;
+                rbu_data.bios_image_size =
+                    rbu_data.image_update_buffer_size;
+                rbu_data.image_update_ordernum = ordernum;
+                rbu_data.dma_alloc = dma_alloc;
+                rc = 0;
+        } else {
+                pr_debug("Not enough memory for image update:"
+                         "size = %ld\n", size);
+                rc = -ENOMEM;
+        }
+
+        return rc;
+}
+
+static ssize_t read_packet_data(char *buffer, loff_t pos, size_t count)
+{
+        int retval;
+        size_t bytes_left;
+        size_t data_length;
+        char *ptempBuf = buffer;
+        unsigned long imagesize;
+
+        /* check to see if we have something to return */
+        if (rbu_data.num_packets == 0) {
+                pr_debug("read_packet_data: no packets written\n");
+                retval = -ENOMEM;
+                goto read_rbu_data_exit;
+        }
+
+        imagesize = rbu_data.num_packets * rbu_data.packetsize;
+
+        if (pos > imagesize) {
+                retval = 0;
+                printk(KERN_WARNING "dell_rbu:read_packet_data: "
+                       "data underrun\n");
+                goto read_rbu_data_exit;
+        }
+
+        bytes_left = imagesize - pos;
+        data_length = min(bytes_left, count);
+
+        if ((retval = packet_read_list(ptempBuf, &data_length)) < 0)
+                goto read_rbu_data_exit;
+
+        if ((pos + count) > imagesize) {
+                rbu_data.packet_read_count = 0;
+                /* this was the last copy */
+                retval = bytes_left;
+        } else
+                retval = count;
+
+      read_rbu_data_exit:
+        return retval;
+}
+
+static ssize_t read_rbu_mono_data(char *buffer, loff_t pos, size_t count)
+{
+        unsigned char *ptemp = NULL;
+        size_t bytes_left = 0;
+        size_t data_length = 0;
+        ssize_t ret_count = 0;
+
+        /* check to see if we have something to return */
+        if ((rbu_data.image_update_buffer == NULL) ||
+            (rbu_data.bios_image_size == 0)) {
+                pr_debug("read_rbu_data_mono: image_update_buffer %p ,"
+                         "bios_image_size %lu\n",
+                         rbu_data.image_update_buffer,
+                         rbu_data.bios_image_size);
+                ret_count = -ENOMEM;
+                goto read_rbu_data_exit;
+        }
+
+        if (pos > rbu_data.bios_image_size) {
+                ret_count = 0;
+                goto read_rbu_data_exit;
+        }
+
+        bytes_left = rbu_data.bios_image_size - pos;
+        data_length = min(bytes_left, count);
+
+        ptemp = rbu_data.image_update_buffer;
+        memcpy(buffer, (ptemp + pos), data_length);
+
+        if ((pos + count) > rbu_data.bios_image_size)
+                /* this was the last copy */
+                ret_count = bytes_left;
+        else
+                ret_count = count;
+      read_rbu_data_exit:
+        return ret_count;
+}
+
+static ssize_t
+read_rbu_data(struct kobject *kobj, char *buffer, loff_t pos, size_t count)
+{
+        ssize_t ret_count = 0;
+
+        spin_lock(&rbu_data.lock);
+
+        if (!strcmp(image_type, "mono"))
+                ret_count = read_rbu_mono_data(buffer, pos, count);
+        else if (!strcmp(image_type, "packet"))
+                ret_count = read_packet_data(buffer, pos, count);
+        else
+                pr_debug("read_rbu_data: invalid image type specified\n");
+
+        spin_unlock(&rbu_data.lock);
+        return ret_count;
+}
+
+static ssize_t
+read_rbu_image_type(struct kobject *kobj, char *buffer, loff_t pos,
+                    size_t count)
+{
+        int size = 0;
+        if (!pos)
+                size = sprintf(buffer, "%s\n", image_type);
+        return size;
+}
+
+static ssize_t
+write_rbu_image_type(struct kobject *kobj, char *buffer, loff_t pos,
+                     size_t count)
+{
+        int rc = count;
+        spin_lock(&rbu_data.lock);
+
+        if (strlen(buffer) < MAX_IMAGE_LENGTH)
+                sscanf(buffer, "%s", image_type);
+        else
+                printk(KERN_WARNING "dell_rbu: image_type is invalid"
+                       "max chars = %d, \n incoming str--%s-- \n",
+                       MAX_IMAGE_LENGTH, buffer);
+
+        /* we must free all previous allocations */
+        packet_empty_list();
+        img_update_free();
+
+        spin_unlock(&rbu_data.lock);
+        return rc;
+
+}
+
+static struct bin_attribute rbu_data_attr = {
+        .attr = {.name = "data",.owner = THIS_MODULE,.mode = 0444},
+        .read = read_rbu_data,
+};
+
+static struct bin_attribute rbu_image_type_attr = {
+        .attr = {.name = "image_type",.owner = THIS_MODULE,.mode = 0644},
+        .read = read_rbu_image_type,
+        .write = write_rbu_image_type,
+};
+
+static void callbackfn_rbu(const struct firmware *fw, void *context)
+{
+        int rc = 0;
+
+        if (!fw || !fw->size)
+                return;
+
+        spin_lock(&rbu_data.lock);
+        if (!strcmp(image_type, "mono")) {
+                if (!img_update_realloc(fw->size))
+                        memcpy(rbu_data.image_update_buffer,
+                               fw->data, fw->size);
+        } else if (!strcmp(image_type, "packet")) {
+                if (!rbu_data.packetsize)
+                        rbu_data.packetsize = fw->size;
+                else if (rbu_data.packetsize != fw->size) {
+                        packet_empty_list();
+                        rbu_data.packetsize = fw->size;
+                }
+                packetize_data(fw->data, fw->size);
+        } else
+                pr_debug("invalid image type specified.\n");
+        spin_unlock(&rbu_data.lock);
+
+        rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG,
+                                     "dell_rbu", &rbu_device->dev,
+                                     &context, callbackfn_rbu);
+        if (rc)
+                printk(KERN_ERR
+                       "dell_rbu:%s request_firmware_nowait failed"
+                       " %d\n", __FUNCTION__, rc);
+}
+
+static int __init dcdrbu_init(void)
+{
+        int rc = 0;
+        spin_lock_init(&rbu_data.lock);
+
+        init_packet_head();
+        rbu_device =
+            platform_device_register_simple("dell_rbu", -1, NULL, 0);
+        if (!rbu_device) {
+                printk(KERN_ERR
+                       "dell_rbu:%s:platform_device_register_simple "
+                       "failed\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        sysfs_create_bin_file(&rbu_device->dev.kobj, &rbu_data_attr);
+        sysfs_create_bin_file(&rbu_device->dev.kobj, &rbu_image_type_attr);
+
+        rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG,
+                                     "dell_rbu", &rbu_device->dev,
+                                     &context, callbackfn_rbu);
+        if (rc)
+                printk(KERN_ERR "dell_rbu:%s:request_firmware_nowait"
+                       " failed %d\n", __FUNCTION__, rc);
+
+        return rc;
+
+}
+
+static __exit void dcdrbu_exit(void)
+{
+        spin_lock(&rbu_data.lock);
+        packet_empty_list();
+        img_update_free();
+        spin_unlock(&rbu_data.lock);
+        platform_device_unregister(rbu_device);
+}
+
+module_exit(dcdrbu_exit);
+module_init(dcdrbu_init);
diff --git a/drivers/i2c/chips/isp1301_omap.c b/drivers/i2c/chips/isp1301_omap.c
index 354a26295672..8ee56d4b3891 100644
--- a/drivers/i2c/chips/isp1301_omap.c
+++ b/drivers/i2c/chips/isp1301_omap.c
@@ -1489,7 +1489,7 @@ static int isp1301_probe(struct i2c_adapter *bus, int address, int kind)
         if (the_transceiver)
                 return 0;
 
-        isp = kcalloc(1, sizeof *isp, GFP_KERNEL);
+        isp = kzalloc(sizeof *isp, GFP_KERNEL);
         if (!isp)
                 return 0;
 
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index bebcc47ab06c..b23322523ef5 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -1068,6 +1068,8 @@ static int nodemgr_hotplug(struct class_device *cdev, char **envp, int num_envp,
         struct unit_directory *ud;
         int i = 0;
         int length = 0;
+        /* ieee1394:venNmoNspNverN */
+        char buf[8 + 1 + 3 + 8 + 2 + 8 + 2 + 8 + 3 + 8 + 1];
 
         if (!cdev)
                 return -ENODEV;
@@ -1094,6 +1096,12 @@ do {								\
         PUT_ENVP("GUID=%016Lx", (unsigned long long)ud->ne->guid);
         PUT_ENVP("SPECIFIER_ID=%06x", ud->specifier_id);
         PUT_ENVP("VERSION=%06x", ud->version);
+        snprintf(buf, sizeof(buf), "ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
+                        ud->vendor_id,
+                        ud->model_id,
+                        ud->specifier_id,
+                        ud->version);
+        PUT_ENVP("MODALIAS=%s", buf);
 
 #undef PUT_ENVP
 
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index fae1c2dcee51..211ba3223f65 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -463,7 +463,7 @@ alloc_group_attrs(ssize_t (*show)(struct ib_port *,
                 return NULL;
 
         for (i = 0; i < len; i++) {
-                element = kcalloc(1, sizeof(struct port_table_attribute),
+                element = kzalloc(sizeof(struct port_table_attribute),
                                   GFP_KERNEL);
                 if (!element)
                         goto err;
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index f8b278d3559b..19c14c4beb44 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -393,6 +393,7 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                                 case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
                                                 case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
                                                 case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
+                                                case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
                                                 default: return -EINVAL;
                                         }
                                         len = NBITS(len) * sizeof(long);
@@ -421,6 +422,13 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                         return copy_to_user(p, dev->snd, len) ? -EFAULT : len;
                                 }
 
+                                if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0))) {
+                                        int len;
+                                        len = NBITS(SW_MAX) * sizeof(long);
+                                        if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                        return copy_to_user(p, dev->sw, len) ? -EFAULT : len;
+                                }
+
                                 if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
                                         int len;
                                         if (!dev->name) return -ENOENT;
diff --git a/drivers/input/gameport/emu10k1-gp.c b/drivers/input/gameport/emu10k1-gp.c
index a0118038330a..462f8d300aae 100644
--- a/drivers/input/gameport/emu10k1-gp.c
+++ b/drivers/input/gameport/emu10k1-gp.c
@@ -75,7 +75,7 @@ static int __devinit emu_probe(struct pci_dev *pdev, const struct pci_device_id
         if (!request_region(ioport, iolen, "emu10k1-gp"))
                 return -EBUSY;
 
-        emu = kcalloc(1, sizeof(struct emu), GFP_KERNEL);
+        emu = kzalloc(sizeof(struct emu), GFP_KERNEL);
         port = gameport_allocate_port();
         if (!emu || !port) {
                 printk(KERN_ERR "emu10k1-gp: Memory allocation failed\n");
diff --git a/drivers/input/gameport/fm801-gp.c b/drivers/input/gameport/fm801-gp.c
index 57615bc63906..47e93daa0fa7 100644
--- a/drivers/input/gameport/fm801-gp.c
+++ b/drivers/input/gameport/fm801-gp.c
@@ -83,7 +83,7 @@ static int __devinit fm801_gp_probe(struct pci_dev *pci, const struct pci_device
         struct fm801_gp *gp;
         struct gameport *port;
 
-        gp = kcalloc(1, sizeof(struct fm801_gp), GFP_KERNEL);
+        gp = kzalloc(sizeof(struct fm801_gp), GFP_KERNEL);
         port = gameport_allocate_port();
         if (!gp || !port) {
                 printk(KERN_ERR "fm801-gp: Memory allocation failed\n");
diff --git a/drivers/input/gameport/ns558.c b/drivers/input/gameport/ns558.c
index 70f051894a3c..d2e55dc956ba 100644
--- a/drivers/input/gameport/ns558.c
+++ b/drivers/input/gameport/ns558.c
@@ -142,7 +142,7 @@ static int ns558_isa_probe(int io)
                         return -EBUSY;
         }
 
-        ns558 = kcalloc(1, sizeof(struct ns558), GFP_KERNEL);
+        ns558 = kzalloc(sizeof(struct ns558), GFP_KERNEL);
         port = gameport_allocate_port();
         if (!ns558 || !port) {
                 printk(KERN_ERR "ns558: Memory allocation failed.\n");
@@ -215,7 +215,7 @@ static int ns558_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *did)
         if (!request_region(ioport, iolen, "ns558-pnp"))
                 return -EBUSY;
 
-        ns558 = kcalloc(1, sizeof(struct ns558), GFP_KERNEL);
+        ns558 = kzalloc(sizeof(struct ns558), GFP_KERNEL);
         port = gameport_allocate_port();
         if (!ns558 || !port) {
                 printk(KERN_ERR "ns558: Memory allocation failed\n");
diff --git a/drivers/input/input.c b/drivers/input/input.c
index a275211c8e1e..88636a204525 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -89,6 +89,15 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
 
                         break;
 
+                case EV_SW:
+
+                        if (code > SW_MAX || !test_bit(code, dev->swbit) || !!test_bit(code, dev->sw) == value)
+                                return;
+
+                        change_bit(code, dev->sw);
+
+                        break;
+
                 case EV_ABS:
 
                         if (code > ABS_MAX || !test_bit(code, dev->absbit))
@@ -402,6 +411,7 @@ static void input_call_hotplug(char *verb, struct input_dev *dev)
         SPRINTF_BIT_A2(ledbit, "LED=", LED_MAX, EV_LED);
         SPRINTF_BIT_A2(sndbit, "SND=", SND_MAX, EV_SND);
         SPRINTF_BIT_A2(ffbit,  "FF=",  FF_MAX, EV_FF);
+        SPRINTF_BIT_A2(swbit,  "SW=",  SW_MAX, EV_SW);
 
         envp[i++] = NULL;
 
@@ -490,6 +500,7 @@ static int input_devices_read(char *buf, char **start, off_t pos, int count, int
                 SPRINTF_BIT_B2(ledbit, "LED=", LED_MAX, EV_LED);
                 SPRINTF_BIT_B2(sndbit, "SND=", SND_MAX, EV_SND);
                 SPRINTF_BIT_B2(ffbit,  "FF=",  FF_MAX, EV_FF);
+                SPRINTF_BIT_B2(swbit,  "SW=",  SW_MAX, EV_SW);
 
                 len += sprintf(buf + len, "\n");
 
diff --git a/drivers/input/joystick/a3d.c b/drivers/input/joystick/a3d.c
index bf34f75b9467..bf65430181fa 100644
--- a/drivers/input/joystick/a3d.c
+++ b/drivers/input/joystick/a3d.c
@@ -269,7 +269,7 @@ static int a3d_connect(struct gameport *gameport, struct gameport_driver *drv)
         int i;
         int err;
 
-        if (!(a3d = kcalloc(1, sizeof(struct a3d), GFP_KERNEL)))
+        if (!(a3d = kzalloc(sizeof(struct a3d), GFP_KERNEL)))
                 return -ENOMEM;
 
         a3d->gameport = gameport;
diff --git a/drivers/input/joystick/adi.c b/drivers/input/joystick/adi.c
index 265962956c63..cf35ae638a0d 100644
--- a/drivers/input/joystick/adi.c
+++ b/drivers/input/joystick/adi.c
@@ -469,7 +469,7 @@ static int adi_connect(struct gameport *gameport, struct gameport_driver *drv)
         int i;
         int err;
 
-        if (!(port = kcalloc(1, sizeof(struct adi_port), GFP_KERNEL)))
+        if (!(port = kzalloc(sizeof(struct adi_port), GFP_KERNEL)))
                 return -ENOMEM;
 
         port->gameport = gameport;
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index c3a5739030c3..64b1313a3c66 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -655,7 +655,7 @@ static int analog_connect(struct gameport *gameport, struct gameport_driver *drv
         int i;
         int err;
 
-        if (!(port = kcalloc(1, sizeof(struct analog_port), GFP_KERNEL)))
+        if (!(port = kzalloc(sizeof(struct analog_port), GFP_KERNEL)))
                 return - ENOMEM;
 
         err = analog_init_port(gameport, drv, port);
diff --git a/drivers/input/joystick/cobra.c b/drivers/input/joystick/cobra.c
index a6002205328f..0b2e9fa26579 100644
--- a/drivers/input/joystick/cobra.c
+++ b/drivers/input/joystick/cobra.c
@@ -163,7 +163,7 @@ static int cobra_connect(struct gameport *gameport, struct gameport_driver *drv)
         int i, j;
         int err;
 
-        if (!(cobra = kcalloc(1, sizeof(struct cobra), GFP_KERNEL)))
+        if (!(cobra = kzalloc(sizeof(struct cobra), GFP_KERNEL)))
                 return -ENOMEM;
 
         cobra->gameport = gameport;
diff --git a/drivers/input/joystick/db9.c b/drivers/input/joystick/db9.c
index fbd3eed07f90..2a3e4bb2da50 100644
--- a/drivers/input/joystick/db9.c
+++ b/drivers/input/joystick/db9.c
@@ -572,7 +572,7 @@ static struct db9 __init *db9_probe(int *config, int nargs)
                 }
         }
 
-        if (!(db9 = kcalloc(1, sizeof(struct db9), GFP_KERNEL))) {
+        if (!(db9 = kzalloc(sizeof(struct db9), GFP_KERNEL))) {
                 parport_put_port(pp);
                 return NULL;
         }
diff --git a/drivers/input/joystick/gamecon.c b/drivers/input/joystick/gamecon.c
index 95bbdd302aad..5427bf9fc862 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -554,7 +554,7 @@ static struct gc __init *gc_probe(int *config, int nargs)
                 return NULL;
         }
 
-        if (!(gc = kcalloc(1, sizeof(struct gc), GFP_KERNEL))) {
+        if (!(gc = kzalloc(sizeof(struct gc), GFP_KERNEL))) {
                 parport_put_port(pp);
                 return NULL;
         }
diff --git a/drivers/input/joystick/gf2k.c b/drivers/input/joystick/gf2k.c
index 7d969420066c..8e4f92b115e6 100644
--- a/drivers/input/joystick/gf2k.c
+++ b/drivers/input/joystick/gf2k.c
@@ -242,7 +242,7 @@ static int gf2k_connect(struct gameport *gameport, struct gameport_driver *drv)
         unsigned char data[GF2K_LENGTH];
         int i, err;
 
-        if (!(gf2k = kcalloc(1, sizeof(struct gf2k), GFP_KERNEL)))
+        if (!(gf2k = kzalloc(sizeof(struct gf2k), GFP_KERNEL)))
                 return -ENOMEM;
 
         gf2k->gameport = gameport;
diff --git a/drivers/input/joystick/grip.c b/drivers/input/joystick/grip.c
index d1500d2562d6..9d3f910dd568 100644
--- a/drivers/input/joystick/grip.c
+++ b/drivers/input/joystick/grip.c
@@ -301,7 +301,7 @@ static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
         int i, j, t;
         int err;
 
-        if (!(grip = kcalloc(1, sizeof(struct grip), GFP_KERNEL)))
+        if (!(grip = kzalloc(sizeof(struct grip), GFP_KERNEL)))
                 return -ENOMEM;
 
         grip->gameport = gameport;
diff --git a/drivers/input/joystick/grip_mp.c b/drivers/input/joystick/grip_mp.c
index 0da7bd133ccf..da17eee6f574 100644
--- a/drivers/input/joystick/grip_mp.c
+++ b/drivers/input/joystick/grip_mp.c
@@ -607,7 +607,7 @@ static int grip_connect(struct gameport *gameport, struct gameport_driver *drv)
         struct grip_mp *grip;
         int err;
 
-        if (!(grip = kcalloc(1, sizeof(struct grip_mp), GFP_KERNEL)))
+        if (!(grip = kzalloc(sizeof(struct grip_mp), GFP_KERNEL)))
                 return -ENOMEM;
 
         grip->gameport = gameport;
diff --git a/drivers/input/joystick/guillemot.c b/drivers/input/joystick/guillemot.c
index f93da7bc082d..6a70ec429f06 100644
--- a/drivers/input/joystick/guillemot.c
+++ b/drivers/input/joystick/guillemot.c
@@ -183,7 +183,7 @@ static int guillemot_connect(struct gameport *gameport, struct gameport_driver *
         int i, t;
         int err;
 
-        if (!(guillemot = kcalloc(1, sizeof(struct guillemot), GFP_KERNEL)))
+        if (!(guillemot = kzalloc(sizeof(struct guillemot), GFP_KERNEL)))
                 return -ENOMEM;
 
         guillemot->gameport = gameport;
diff --git a/drivers/input/joystick/interact.c b/drivers/input/joystick/interact.c
index 9d3f8c38cb09..d7b3472bd686 100644
--- a/drivers/input/joystick/interact.c
+++ b/drivers/input/joystick/interact.c
@@ -212,7 +212,7 @@ static int interact_connect(struct gameport *gameport, struct gameport_driver *d
         int i, t;
         int err;
 
-        if (!(interact = kcalloc(1, sizeof(struct interact), GFP_KERNEL)))
+        if (!(interact = kzalloc(sizeof(struct interact), GFP_KERNEL)))
                 return -ENOMEM;
 
         interact->gameport = gameport;
diff --git a/drivers/input/joystick/sidewinder.c b/drivers/input/joystick/sidewinder.c
index 47144a7ed9e7..9e0353721a35 100644
--- a/drivers/input/joystick/sidewinder.c
+++ b/drivers/input/joystick/sidewinder.c
@@ -590,7 +590,7 @@ static int sw_connect(struct gameport *gameport, struct gameport_driver *drv)
 
         comment[0] = 0;
 
-        sw = kcalloc(1, sizeof(struct sw), GFP_KERNEL);
+        sw = kzalloc(sizeof(struct sw), GFP_KERNEL);
         buf = kmalloc(SW_LENGTH, GFP_KERNEL);
         idbuf = kmalloc(SW_LENGTH, GFP_KERNEL);
         if (!sw || !buf || !idbuf) {
diff --git a/drivers/input/joystick/tmdc.c b/drivers/input/joystick/tmdc.c
index 9eb9954cac6e..7431efc4330e 100644
--- a/drivers/input/joystick/tmdc.c
+++ b/drivers/input/joystick/tmdc.c
@@ -262,7 +262,7 @@ static int tmdc_connect(struct gameport *gameport, struct gameport_driver *drv)
         int i, j, k, l, m;
         int err;
 
-        if (!(tmdc = kcalloc(1, sizeof(struct tmdc), GFP_KERNEL)))
+        if (!(tmdc = kzalloc(sizeof(struct tmdc), GFP_KERNEL)))
                 return -ENOMEM;
 
         tmdc->gameport = gameport;
diff --git a/drivers/input/joystick/turbografx.c b/drivers/input/joystick/turbografx.c
index 28100d461cb7..0c5b9c8297cd 100644
--- a/drivers/input/joystick/turbografx.c
+++ b/drivers/input/joystick/turbografx.c
@@ -178,7 +178,7 @@ static struct tgfx __init *tgfx_probe(int *config, int nargs)
                 return NULL;
         }
 
-        if (!(tgfx = kcalloc(1, sizeof(struct tgfx), GFP_KERNEL))) {
+        if (!(tgfx = kzalloc(sizeof(struct tgfx), GFP_KERNEL))) {
                 parport_put_port(pp);
                 return NULL;
         }
diff --git a/drivers/input/keyboard/corgikbd.c b/drivers/input/keyboard/corgikbd.c
index a8551711e8d6..cd4b6e795013 100644
--- a/drivers/input/keyboard/corgikbd.c
+++ b/drivers/input/keyboard/corgikbd.c
@@ -16,6 +16,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/jiffies.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <asm/irq.h>
@@ -32,7 +33,6 @@
 /* zero code, 124 scancodes + 3 hinge combinations */
 #define NR_SCANCODES            ( SCANCODE(KB_ROWS-1,KB_COLS-1) +1 +1 +3 )
 #define SCAN_INTERVAL           (HZ/10)
-#define CORGIKBD_PRESSED        1
 
 #define HINGE_SCAN_INTERVAL             (HZ/4)
 
@@ -73,25 +73,13 @@ struct corgikbd {
         struct input_dev input;
         char phys[32];
 
-        unsigned char state[ARRAY_SIZE(corgikbd_keycode)];
         spinlock_t lock;
-
         struct timer_list timer;
         struct timer_list htimer;
-};
 
-static void handle_scancode(unsigned int pressed,unsigned int scancode, struct corgikbd *corgikbd_data)
-{
-        if (pressed && !(corgikbd_data->state[scancode] & CORGIKBD_PRESSED)) {
-                corgikbd_data->state[scancode] |= CORGIKBD_PRESSED;
-                input_report_key(&corgikbd_data->input, corgikbd_data->keycode[scancode], 1);
-                if (corgikbd_data->keycode[scancode] == CORGI_KEY_OFF)
-                        input_event(&corgikbd_data->input, EV_PWR, CORGI_KEY_OFF, 1);
-        } else if (!pressed && corgikbd_data->state[scancode] & CORGIKBD_PRESSED) {
-                corgikbd_data->state[scancode] &= ~CORGIKBD_PRESSED;
-                input_report_key(&corgikbd_data->input, corgikbd_data->keycode[scancode], 0);
-        }
-}
+        unsigned int suspended;
+        unsigned long suspend_jiffies;
+};
 
 #define KB_DISCHARGE_DELAY      10
 #define KB_ACTIVATE_DELAY       10
@@ -105,36 +93,36 @@ static void handle_scancode(unsigned int pressed,unsigned int scancode, struct c
  */
 static inline void corgikbd_discharge_all(void)
 {
-        // STROBE All HiZ
+        /* STROBE All HiZ */
         GPCR2  = CORGI_GPIO_ALL_STROBE_BIT;
         GPDR2 &= ~CORGI_GPIO_ALL_STROBE_BIT;
 }
 
 static inline void corgikbd_activate_all(void)
 {
-        // STROBE ALL -> High
+        /* STROBE ALL -> High */
         GPSR2  = CORGI_GPIO_ALL_STROBE_BIT;
         GPDR2 |= CORGI_GPIO_ALL_STROBE_BIT;
 
         udelay(KB_DISCHARGE_DELAY);
 
-        // Clear any interrupts we may have triggered when altering the GPIO lines
+        /* Clear any interrupts we may have triggered when altering the GPIO lines */
         GEDR1 = CORGI_GPIO_HIGH_SENSE_BIT;
         GEDR2 = CORGI_GPIO_LOW_SENSE_BIT;
 }
 
 static inline void corgikbd_activate_col(int col)
 {
-        // STROBE col -> High, not col -> HiZ
+        /* STROBE col -> High, not col -> HiZ */
         GPSR2 = CORGI_GPIO_STROBE_BIT(col);
         GPDR2 = (GPDR2 & ~CORGI_GPIO_ALL_STROBE_BIT) | CORGI_GPIO_STROBE_BIT(col);
 }
 
 static inline void corgikbd_reset_col(int col)
 {
-        // STROBE col -> Low
+        /* STROBE col -> Low */
         GPCR2 = CORGI_GPIO_STROBE_BIT(col);
-        // STROBE col -> out, not col -> HiZ
+        /* STROBE col -> out, not col -> HiZ */
         GPDR2 = (GPDR2 & ~CORGI_GPIO_ALL_STROBE_BIT) | CORGI_GPIO_STROBE_BIT(col);
 }
 
@@ -149,10 +137,13 @@ static inline void corgikbd_reset_col(int col)
 /* Scan the hardware keyboard and push any changes up through the input layer */
 static void corgikbd_scankeyboard(struct corgikbd *corgikbd_data, struct pt_regs *regs)
 {
-        unsigned int row, col, rowd, scancode;
+        unsigned int row, col, rowd;
         unsigned long flags;
         unsigned int num_pressed;
 
+        if (corgikbd_data->suspended)
+                return;
+
         spin_lock_irqsave(&corgikbd_data->lock, flags);
 
         if (regs)
@@ -173,10 +164,21 @@ static void corgikbd_scankeyboard(struct corgikbd *corgikbd_data, struct pt_regs
 
                 rowd = GET_ROWS_STATUS(col);
                 for (row = 0; row < KB_ROWS; row++) {
+                        unsigned int scancode, pressed;
+
                         scancode = SCANCODE(row, col);
-                        handle_scancode((rowd & KB_ROWMASK(row)), scancode, corgikbd_data);
-                        if (rowd & KB_ROWMASK(row))
+                        pressed = rowd & KB_ROWMASK(row);
+
+                        input_report_key(&corgikbd_data->input, corgikbd_data->keycode[scancode], pressed);
+
+                        if (pressed)
                                 num_pressed++;
+
+                        if (pressed && (corgikbd_data->keycode[scancode] == CORGI_KEY_OFF)
+                                        && time_after(jiffies, corgikbd_data->suspend_jiffies + HZ)) {
+                                input_event(&corgikbd_data->input, EV_PWR, CORGI_KEY_OFF, 1);
+                                corgikbd_data->suspend_jiffies=jiffies;
+                        }
                 }
                 corgikbd_reset_col(col);
         }
@@ -221,8 +223,11 @@ static void corgikbd_timer_callback(unsigned long data)
  * The hinge switches generate no interrupt so they need to be
  * monitored by a timer.
  *
- * When we detect changes, we debounce it and then pass the three
- * positions the system can take as keypresses to the input system.
+ * We debounce the switches and pass them to the input system.
+ *
+ *  gprr == 0x00 - Keyboard with Landscape Screen
+ *          0x08 - No Keyboard with Portrait Screen
+ *          0x0c - Keyboard and Screen Closed
  */
 
 #define HINGE_STABLE_COUNT 2
@@ -235,7 +240,7 @@ static void corgikbd_hinge_timer(unsigned long data)
         unsigned long gprr;
         unsigned long flags;
 
-        gprr = read_scoop_reg(SCOOP_GPRR) & (CORGI_SCP_SWA | CORGI_SCP_SWB);
+        gprr = read_scoop_reg(&corgiscoop_device.dev, SCOOP_GPRR) & (CORGI_SCP_SWA | CORGI_SCP_SWB);
         if (gprr != sharpsl_hinge_state) {
                 hinge_count = 0;
                 sharpsl_hinge_state = gprr;
@@ -244,9 +249,8 @@ static void corgikbd_hinge_timer(unsigned long data)
                 if (hinge_count >= HINGE_STABLE_COUNT) {
                         spin_lock_irqsave(&corgikbd_data->lock, flags);
 
-                        handle_scancode((sharpsl_hinge_state == 0x00), 125, corgikbd_data); /* Keyboard with Landscape Screen */
-                        handle_scancode((sharpsl_hinge_state == 0x08), 126, corgikbd_data); /* No Keyboard with Portrait Screen */
-                        handle_scancode((sharpsl_hinge_state == 0x0c), 127, corgikbd_data); /* Keyboard and Screen Closed  */
+                        input_report_switch(&corgikbd_data->input, SW_0, ((sharpsl_hinge_state & CORGI_SCP_SWA) != 0));
+                        input_report_switch(&corgikbd_data->input, SW_1, ((sharpsl_hinge_state & CORGI_SCP_SWB) != 0));
                         input_sync(&corgikbd_data->input);
 
                         spin_unlock_irqrestore(&corgikbd_data->lock, flags);
@@ -255,19 +259,45 @@ static void corgikbd_hinge_timer(unsigned long data)
         mod_timer(&corgikbd_data->htimer, jiffies + HINGE_SCAN_INTERVAL);
 }
 
+#ifdef CONFIG_PM
+static int corgikbd_suspend(struct device *dev, pm_message_t state, uint32_t level)
+{
+        if (level == SUSPEND_POWER_DOWN) {
+                struct corgikbd *corgikbd = dev_get_drvdata(dev);
+                corgikbd->suspended = 1;
+        }
+        return 0;
+}
+
+static int corgikbd_resume(struct device *dev, uint32_t level)
+{
+        if (level == RESUME_POWER_ON) {
+                struct corgikbd *corgikbd = dev_get_drvdata(dev);
+
+                /* Upon resume, ignore the suspend key for a short while */
+                corgikbd->suspend_jiffies=jiffies;
+                corgikbd->suspended = 0;
+        }
+        return 0;
+}
+#else
+#define corgikbd_suspend        NULL
+#define corgikbd_resume         NULL
+#endif
+
 static int __init corgikbd_probe(struct device *dev)
 {
         int i;
         struct corgikbd *corgikbd;
 
-        corgikbd = kcalloc(1, sizeof(struct corgikbd), GFP_KERNEL);
+        corgikbd = kzalloc(sizeof(struct corgikbd), GFP_KERNEL);
         if (!corgikbd)
                 return -ENOMEM;
 
         dev_set_drvdata(dev,corgikbd);
         strcpy(corgikbd->phys, "corgikbd/input0");
 
-        spin_lock_init(corgikbd->lock);
+        spin_lock_init(&corgikbd->lock);
 
         /* Init Keyboard rescan timer */
         init_timer(&corgikbd->timer);
@@ -279,6 +309,8 @@ static int __init corgikbd_probe(struct device *dev)
         corgikbd->htimer.function = corgikbd_hinge_timer;
         corgikbd->htimer.data = (unsigned long) corgikbd;
 
+        corgikbd->suspend_jiffies=jiffies;
+
         init_input_dev(&corgikbd->input);
         corgikbd->input.private = corgikbd;
         corgikbd->input.name = "Corgi Keyboard";
@@ -288,7 +320,7 @@ static int __init corgikbd_probe(struct device *dev)
         corgikbd->input.id.vendor = 0x0001;
         corgikbd->input.id.product = 0x0001;
         corgikbd->input.id.version = 0x0100;
-        corgikbd->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_PWR);
+        corgikbd->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_PWR) | BIT(EV_SW);
         corgikbd->input.keycode = corgikbd->keycode;
         corgikbd->input.keycodesize = sizeof(unsigned char);
         corgikbd->input.keycodemax = ARRAY_SIZE(corgikbd_keycode);
@@ -297,6 +329,8 @@ static int __init corgikbd_probe(struct device *dev)
         for (i = 0; i < ARRAY_SIZE(corgikbd_keycode); i++)
                 set_bit(corgikbd->keycode[i], corgikbd->input.keybit);
         clear_bit(0, corgikbd->input.keybit);
+        set_bit(SW_0, corgikbd->input.swbit);
+        set_bit(SW_1, corgikbd->input.swbit);
 
         input_register_device(&corgikbd->input);
         mod_timer(&corgikbd->htimer, jiffies + HINGE_SCAN_INTERVAL);
@@ -343,6 +377,8 @@ static struct device_driver corgikbd_driver = {
         .bus            = &platform_bus_type,
         .probe          = corgikbd_probe,
         .remove         = corgikbd_remove,
+        .suspend        = corgikbd_suspend,
+        .resume         = corgikbd_resume,
 };
 
 static int __devinit corgikbd_init(void)
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 2bb2fe78bdca..12bdd3eff923 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -883,7 +883,7 @@ static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
                 psmouse_deactivate(parent);
         }
 
-        if (!(psmouse = kcalloc(1, sizeof(struct psmouse), GFP_KERNEL))) {
+        if (!(psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL))) {
                 retval = -ENOMEM;
                 goto out;
         }
diff --git a/drivers/input/serio/serport.c b/drivers/input/serio/serport.c
index 79ca38469159..1bd88fca0542 100644
--- a/drivers/input/serio/serport.c
+++ b/drivers/input/serio/serport.c
@@ -87,7 +87,7 @@ static int serport_ldisc_open(struct tty_struct *tty)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        serport = kcalloc(1, sizeof(struct serport), GFP_KERNEL);
+        serport = kzalloc(sizeof(struct serport), GFP_KERNEL);
         if (!serport)
                 return -ENOMEM;
 
@@ -165,7 +165,7 @@ static ssize_t serport_ldisc_read(struct tty_struct * tty, struct file * file, u
         if (test_and_set_bit(SERPORT_BUSY, &serport->flags))
                 return -EBUSY;
 
-        serport->serio = serio = kcalloc(1, sizeof(struct serio), GFP_KERNEL);
+        serport->serio = serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
         if (!serio)
                 return -ENOMEM;
 
diff --git a/drivers/input/touchscreen/corgi_ts.c b/drivers/input/touchscreen/corgi_ts.c
index 3f8b61cfbc37..5d19261b884f 100644
--- a/drivers/input/touchscreen/corgi_ts.c
+++ b/drivers/input/touchscreen/corgi_ts.c
@@ -53,11 +53,8 @@ struct corgi_ts {
 
 #define SyncHS()        while((STATUS_HSYNC) == 0); while((STATUS_HSYNC) != 0);
 #define CCNT(a)         asm volatile ("mrc p14, 0, %0, C1, C0, 0" : "=r"(a))
-#define CCNT_ON()       {int pmnc = 1; asm volatile ("mcr p14, 0, %0, C0, C0, 0" : : "r"(pmnc));}
-#define CCNT_OFF()      {int pmnc = 0; asm volatile ("mcr p14, 0, %0, C0, C0, 0" : : "r"(pmnc));}
-
-#define WAIT_HS_400_VGA         7013U   // 17.615us
-#define WAIT_HS_400_QVGA        16622U  // 41.750us
+#define PMNC_GET(x)     asm volatile ("mrc p14, 0, %0, C0, C0, 0" : "=r"(x))
+#define PMNC_SET(x)     asm volatile ("mcr p14, 0, %0, C0, C0, 0" : : "r"(x))
 
 
 /* ADS7846 Touch Screen Controller bit definitions */
@@ -69,41 +66,29 @@ struct corgi_ts {
 #define ADSCTRL_STS             (1u << 7)       /* Start Bit */
 
 /* External Functions */
-extern int w100fb_get_xres(void);
-extern int w100fb_get_blanking(void);
-extern int w100fb_get_fastsysclk(void);
+extern unsigned long w100fb_get_hsynclen(struct device *dev);
 extern unsigned int get_clk_frequency_khz(int info);
 
 static unsigned long calc_waittime(void)
 {
-        int w100fb_xres = w100fb_get_xres();
-        unsigned int waittime = 0;
-
-        if (w100fb_xres == 480 || w100fb_xres == 640) {
-                waittime = WAIT_HS_400_VGA * get_clk_frequency_khz(0) / 398131U;
-
-                if (w100fb_get_fastsysclk() == 100)
-                        waittime = waittime * 75 / 100;
-
-                if (w100fb_xres == 640)
-                        waittime *= 3;
+        unsigned long hsync_len = w100fb_get_hsynclen(&corgifb_device.dev);
 
-                return waittime;
-        }
-
-        return WAIT_HS_400_QVGA * get_clk_frequency_khz(0) / 398131U;
+        if (hsync_len)
+                return get_clk_frequency_khz(0)*1000/hsync_len;
+        else
+                return 0;
 }
 
 static int sync_receive_data_send_cmd(int doRecive, int doSend, unsigned int address, unsigned long wait_time)
 {
+        unsigned long timer1 = 0, timer2, pmnc = 0;
         int pos = 0;
-        unsigned long timer1 = 0, timer2;
-        int dosleep;
 
-        dosleep = !w100fb_get_blanking();
+        if (wait_time && doSend) {
+                PMNC_GET(pmnc);
+                if (!(pmnc & 0x01))
+                        PMNC_SET(0x01);
 
-        if (dosleep && doSend) {
-                CCNT_ON();
                 /* polling HSync */
                 SyncHS();
                 /* get CCNT */
@@ -119,11 +104,11 @@ static int sync_receive_data_send_cmd(int doRecive, int doSend, unsigned int add
                 corgi_ssp_ads7846_put(cmd);
                 corgi_ssp_ads7846_get();
 
-                if (dosleep) {
+                if (wait_time) {
                         /* Wait after HSync */
                         CCNT(timer2);
                         if (timer2-timer1 > wait_time) {
-                                /* timeout */
+                                /* too slow - timeout, try again */
                                 SyncHS();
                                 /* get OSCR */
                                 CCNT(timer1);
@@ -134,8 +119,8 @@ static int sync_receive_data_send_cmd(int doRecive, int doSend, unsigned int add
                                 CCNT(timer2);
                 }
                 corgi_ssp_ads7846_put(cmd);
-                if (dosleep)
-                        CCNT_OFF();
+                if (wait_time && !(pmnc & 0x01))
+                        PMNC_SET(pmnc);
         }
         return pos;
 }
@@ -244,7 +229,7 @@ static irqreturn_t ts_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 }
 
 #ifdef CONFIG_PM
-static int corgits_suspend(struct device *dev, uint32_t state, uint32_t level)
+static int corgits_suspend(struct device *dev, pm_message_t state, uint32_t level)
 {
         if (level == SUSPEND_POWER_DOWN) {
                 struct corgi_ts *corgi_ts = dev_get_drvdata(dev);
diff --git a/drivers/isdn/hisax/hisax.h b/drivers/isdn/hisax/hisax.h
index 17cf7663c582..26c545fa223b 100644
--- a/drivers/isdn/hisax/hisax.h
+++ b/drivers/isdn/hisax/hisax.h
@@ -10,7 +10,6 @@
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/major.h>
-#include <asm/segment.h>
 #include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
@@ -1242,6 +1241,8 @@ struct IsdnCardState {
 
 #ifdef CONFIG_HISAX_ENTERNOW_PCI
 #define CARD_FN_ENTERNOW_PCI 1
+#else
+#define CARD_FN_ENTERNOW_PCI 0
 #endif
 
 #define TEI_PER_CARD 1
diff --git a/drivers/isdn/i4l/isdn_v110.c b/drivers/isdn/i4l/isdn_v110.c
index f47f2b9846d8..38619e8cd823 100644
--- a/drivers/isdn/i4l/isdn_v110.c
+++ b/drivers/isdn/i4l/isdn_v110.c
@@ -516,11 +516,11 @@ buffer_full:
 }
 
 int
-isdn_v110_stat_callback(int idx, isdn_ctrl * c)
+isdn_v110_stat_callback(int idx, isdn_ctrl *c)
 {
         isdn_v110_stream *v = NULL;
         int i;
-        int ret;
+        int ret = 0;
 
         if (idx < 0)
                 return 0;
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 45754bb6a799..9de000131a8a 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -239,6 +239,11 @@ static void vm_dp_init(struct dpages *dp, void *data)
         dp->context_ptr = data;
 }
 
+static void dm_bio_destructor(struct bio *bio)
+{
+        bio_free(bio, _bios);
+}
+
 /*-----------------------------------------------------------------
  * IO routines that accept a list of pages.
  *---------------------------------------------------------------*/
@@ -263,6 +268,7 @@ static void do_region(int rw, unsigned int region, struct io_region *where,
                 bio->bi_bdev = where->bdev;
                 bio->bi_end_io = endio;
                 bio->bi_private = io;
+                bio->bi_destructor = dm_bio_destructor;
                 bio_set_region(bio, region);
 
                 /*
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index d487d9deb98e..930b9fc27953 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -399,6 +399,11 @@ struct clone_info {
         unsigned short idx;
 };
 
+static void dm_bio_destructor(struct bio *bio)
+{
+        bio_free(bio, dm_set);
+}
+
 /*
  * Creates a little bio that is just does part of a bvec.
  */
@@ -410,6 +415,7 @@ static struct bio *split_bvec(struct bio *bio, sector_t sector,
         struct bio_vec *bv = bio->bi_io_vec + idx;
 
         clone = bio_alloc_bioset(GFP_NOIO, 1, dm_set);
+        clone->bi_destructor = dm_bio_destructor;
         *clone->bi_io_vec = *bv;
 
         clone->bi_sector = sector;
diff --git a/drivers/media/dvb/bt8xx/Kconfig b/drivers/media/dvb/bt8xx/Kconfig
index b12545f093f8..1e85d16491b0 100644
--- a/drivers/media/dvb/bt8xx/Kconfig
+++ b/drivers/media/dvb/bt8xx/Kconfig
@@ -1,5 +1,5 @@
 config DVB_BT8XX
-        tristate "Nebula/Pinnacle PCTV/Twinhan PCI cards"
+        tristate "BT8xx based PCI cards"
         depends on DVB_CORE && PCI && VIDEO_BT848
         select DVB_MT352
         select DVB_SP887X
@@ -8,8 +8,8 @@ config DVB_BT8XX
         select DVB_OR51211
         help
           Support for PCI cards based on the Bt8xx PCI bridge. Examples are
-          the Nebula cards, the Pinnacle PCTV cards, the Twinhan DST cards and
-          pcHDTV HD2000 cards.
+          the Nebula cards, the Pinnacle PCTV cards, the Twinhan DST cards,
+          the pcHDTV HD2000 cards, and certain AVerMedia cards.
 
           Since these cards have no MPEG decoder onboard, they transmit
           only compressed MPEG data over the PCI bus, so you need
diff --git a/drivers/media/dvb/frontends/lgdt330x.c b/drivers/media/dvb/frontends/lgdt330x.c
index 1f1cd7a8d500..7142b9c51dd2 100644
--- a/drivers/media/dvb/frontends/lgdt330x.c
+++ b/drivers/media/dvb/frontends/lgdt330x.c
@@ -69,8 +69,8 @@ struct lgdt330x_state
 };
 
 static int i2c_write_demod_bytes (struct lgdt330x_state* state,
-                           u8 *buf, /* data bytes to send */
-                           int len  /* number of bytes to send */ )
+                                  u8 *buf, /* data bytes to send */
+                                  int len  /* number of bytes to send */ )
 {
         struct i2c_msg msg =
                 { .addr = state->config->demod_address,
@@ -129,13 +129,13 @@ static int lgdt3302_SwReset(struct lgdt330x_state* state)
         };
 
         ret = i2c_write_demod_bytes(state,
-                             reset, sizeof(reset));
+                                    reset, sizeof(reset));
         if (ret == 0) {
 
                 /* force reset high (inactive) and unmask interrupts */
                 reset[1] = 0x7f;
                 ret = i2c_write_demod_bytes(state,
-                                     reset, sizeof(reset));
+                                            reset, sizeof(reset));
         }
         return ret;
 }
@@ -149,13 +149,13 @@ static int lgdt3303_SwReset(struct lgdt330x_state* state)
         };
 
         ret = i2c_write_demod_bytes(state,
-                             reset, sizeof(reset));
+                                    reset, sizeof(reset));
         if (ret == 0) {
 
                 /* force reset high (inactive) */
                 reset[1] = 0x01;
                 ret = i2c_write_demod_bytes(state,
-                                     reset, sizeof(reset));
+                                            reset, sizeof(reset));
         }
         return ret;
 }
@@ -172,7 +172,6 @@ static int lgdt330x_SwReset(struct lgdt330x_state* state)
         }
 }
 
-
 static int lgdt330x_init(struct dvb_frontend* fe)
 {
         /* Hardware reset is done using gpio[0] of cx23880x chip.
@@ -229,13 +228,13 @@ static int lgdt330x_init(struct dvb_frontend* fe)
         case LGDT3302:
                 chip_name = "LGDT3302";
                 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
-                                                                        sizeof(lgdt3302_init_data));
-                break;
+                                            sizeof(lgdt3302_init_data));
+                break;
         case LGDT3303:
                 chip_name = "LGDT3303";
                 err = i2c_write_demod_bytes(state, lgdt3303_init_data,
-                                                                        sizeof(lgdt3303_init_data));
-                break;
+                                            sizeof(lgdt3303_init_data));
+                break;
         default:
                 chip_name = "undefined";
                 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
@@ -262,15 +261,15 @@ static int lgdt330x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
         switch (state->config->demod_chip) {
         case LGDT3302:
                 err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
-                                                                  buf, sizeof(buf));
-                break;
+                                           buf, sizeof(buf));
+                break;
         case LGDT3303:
                 err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
-                                                                  buf, sizeof(buf));
-                break;
+                                           buf, sizeof(buf));
+                break;
         default:
                 printk(KERN_WARNING
-                           "Only LGDT3302 and LGDT3303 are supported chips.\n");
+                       "Only LGDT3302 and LGDT3303 are supported chips.\n");
                 err = -ENODEV;
         }
 
@@ -330,7 +329,7 @@ static int lgdt330x_set_parameters(struct dvb_frontend* fe,
 
                         if (state->config->demod_chip == LGDT3303) {
                                 err = i2c_write_demod_bytes(state, lgdt3303_8vsb_44_data,
-                                                                                        sizeof(lgdt3303_8vsb_44_data));
+                                                            sizeof(lgdt3303_8vsb_44_data));
                         }
                         break;
 
@@ -378,18 +377,19 @@ static int lgdt330x_set_parameters(struct dvb_frontend* fe,
 
                 /* Select the requested mode */
                 i2c_write_demod_bytes(state, top_ctrl_cfg,
-                                                          sizeof(top_ctrl_cfg));
-                state->config->set_ts_params(fe, 0);
+                                      sizeof(top_ctrl_cfg));
+                if (state->config->set_ts_params)
+                        state->config->set_ts_params(fe, 0);
                 state->current_modulation = param->u.vsb.modulation;
         }
 
-        /* Change only if we are actually changing the channel */
-        if (state->current_frequency != param->frequency) {
-                /* Tune to the new frequency */
+        /* Tune to the specified frequency */
+        if (state->config->pll_set)
                 state->config->pll_set(fe, param);
-                /* Keep track of the new frequency */
-                state->current_frequency = param->frequency;
-        }
+
+        /* Keep track of the new frequency */
+        state->current_frequency = param->frequency;
+
         lgdt330x_SwReset(state);
         return 0;
 }
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 810e7aac0a53..3e6f5347da21 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -29,7 +29,7 @@ obj-$(CONFIG_VIDEO_ZORAN_LML33R10) += saa7114.o adv7170.o zr36060.o
 obj-$(CONFIG_VIDEO_ZORAN) += zr36067.o videocodec.o
 obj-$(CONFIG_VIDEO_PMS) += pms.o
 obj-$(CONFIG_VIDEO_PLANB) += planb.o
-obj-$(CONFIG_VIDEO_VINO) += vino.o
+obj-$(CONFIG_VIDEO_VINO) += vino.o saa7191.o indycam.o
 obj-$(CONFIG_VIDEO_STRADIS) += stradis.o
 obj-$(CONFIG_VIDEO_CPIA) += cpia.o
 obj-$(CONFIG_VIDEO_CPIA_PP) += cpia_pp.o
diff --git a/drivers/media/video/adv7170.c b/drivers/media/video/adv7170.c
index 52e32f05d625..1ca2b67aedfb 100644
--- a/drivers/media/video/adv7170.c
+++ b/drivers/media/video/adv7170.c
@@ -43,7 +43,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/adv7175.c b/drivers/media/video/adv7175.c
index b5ed9544bdea..173bca1e0295 100644
--- a/drivers/media/video/adv7175.c
+++ b/drivers/media/video/adv7175.c
@@ -39,7 +39,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/bt819.c b/drivers/media/video/bt819.c
index c6cfa7c48b04..3ee0afca76a7 100644
--- a/drivers/media/video/bt819.c
+++ b/drivers/media/video/bt819.c
@@ -43,7 +43,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/bt856.c b/drivers/media/video/bt856.c
index c13d28658868..8eb871d0e85b 100644
--- a/drivers/media/video/bt856.c
+++ b/drivers/media/video/bt856.c
@@ -43,7 +43,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/indycam.c b/drivers/media/video/indycam.c
new file mode 100644
index 000000000000..b2b0384cd4b9
--- /dev/null
+++ b/drivers/media/video/indycam.c
@@ -0,0 +1,412 @@
+/*
+ *  indycam.c - Silicon Graphics IndyCam digital camera driver
+ *
+ *  Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
+ *  Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+
+#include <linux/videodev.h>
+/* IndyCam decodes stream of photons into digital image representation ;-) */
+#include <linux/video_decoder.h>
+#include <linux/i2c.h>
+
+#include "indycam.h"
+
+//#define INDYCAM_DEBUG
+
+#define INDYCAM_MODULE_VERSION "0.0.3"
+
+MODULE_DESCRIPTION("SGI IndyCam driver");
+MODULE_VERSION(INDYCAM_MODULE_VERSION);
+MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
+MODULE_LICENSE("GPL");
+
+#ifdef INDYCAM_DEBUG
+#define dprintk(x...) printk("IndyCam: " x);
+#define indycam_regdump(client) indycam_regdump_debug(client)
+#else
+#define dprintk(x...)
+#define indycam_regdump(client)
+#endif
+
+#define VINO_ADAPTER    (I2C_ALGO_SGI | I2C_HW_SGI_VINO)
+
+struct indycam {
+        struct i2c_client *client;
+        int version;
+};
+
+static struct i2c_driver i2c_driver_indycam;
+
+static const unsigned char initseq[] = {
+        INDYCAM_CONTROL_AGCENA,         /* INDYCAM_CONTROL */
+        INDYCAM_SHUTTER_DEFAULT,        /* INDYCAM_SHUTTER */
+        INDYCAM_GAIN_DEFAULT,           /* INDYCAM_GAIN */
+        0x00,                           /* INDYCAM_BRIGHTNESS (read-only) */
+        INDYCAM_RED_BALANCE_DEFAULT,    /* INDYCAM_RED_BALANCE */
+        INDYCAM_BLUE_BALANCE_DEFAULT,   /* INDYCAM_BLUE_BALANCE */
+        INDYCAM_RED_SATURATION_DEFAULT, /* INDYCAM_RED_SATURATION */
+        INDYCAM_BLUE_SATURATION_DEFAULT,/* INDYCAM_BLUE_SATURATION */
+};
+
+/* IndyCam register handling */
+
+static int indycam_read_reg(struct i2c_client *client, unsigned char reg,
+                             unsigned char *value)
+{
+        int ret;
+
+        if (reg == INDYCAM_RESET) {
+                dprintk("indycam_read_reg(): "
+                        "skipping write-only register %d\n", reg);
+                *value = 0;
+                return 0;
+        }
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0) {
+                printk(KERN_ERR "IndyCam: indycam_read_reg(): read failed, "
+                       "register = 0x%02x\n", reg);
+                return ret;
+        }
+
+        *value = (unsigned char)ret;
+
+        return 0;
+}
+
+static int indycam_write_reg(struct i2c_client *client, unsigned char reg,
+                             unsigned char value)
+{
+        int err;
+
+        if ((reg == INDYCAM_BRIGHTNESS)
+            || (reg == INDYCAM_VERSION)) {
+                dprintk("indycam_write_reg(): "
+                        "skipping read-only register %d\n", reg);
+                return 0;
+        }
+
+        dprintk("Writing Reg %d = 0x%02x\n", reg, value);
+        err = i2c_smbus_write_byte_data(client, reg, value);
+        if (err) {
+                printk(KERN_ERR "IndyCam: indycam_write_reg(): write failed, "
+                       "register = 0x%02x, value = 0x%02x\n", reg, value);
+        }
+        return err;
+}
+
+static int indycam_write_block(struct i2c_client *client, unsigned char reg,
+                                unsigned char length, unsigned char *data)
+{
+        unsigned char i;
+        int err;
+
+        for (i = reg; i < length; i++) {
+                err = indycam_write_reg(client, reg + i, data[i]);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+/* Helper functions */
+
+#ifdef INDYCAM_DEBUG
+static void indycam_regdump_debug(struct i2c_client *client)
+{
+        int i;
+        unsigned char val;
+
+        for (i = 0; i < 9; i++) {
+                indycam_read_reg(client, i, &val);
+                dprintk("Reg %d = 0x%02x\n", i, val);
+        }
+}
+#endif
+
+static int indycam_get_controls(struct i2c_client *client,
+                                struct indycam_control *ctrl)
+{
+        unsigned char ctrl_reg;
+
+        indycam_read_reg(client, INDYCAM_CONTROL, &ctrl_reg);
+        ctrl->agc = (ctrl_reg & INDYCAM_CONTROL_AGCENA)
+                ? INDYCAM_VALUE_ENABLED
+                : INDYCAM_VALUE_DISABLED;
+        ctrl->awb = (ctrl_reg & INDYCAM_CONTROL_AWBCTL)
+                ? INDYCAM_VALUE_ENABLED
+                : INDYCAM_VALUE_DISABLED;
+        indycam_read_reg(client, INDYCAM_SHUTTER,
+                         (unsigned char *)&ctrl->shutter);
+        indycam_read_reg(client, INDYCAM_GAIN,
+                         (unsigned char *)&ctrl->gain);
+        indycam_read_reg(client, INDYCAM_RED_BALANCE,
+                         (unsigned char *)&ctrl->red_balance);
+        indycam_read_reg(client, INDYCAM_BLUE_BALANCE,
+                         (unsigned char *)&ctrl->blue_balance);
+        indycam_read_reg(client, INDYCAM_RED_SATURATION,
+                         (unsigned char *)&ctrl->red_saturation);
+        indycam_read_reg(client, INDYCAM_BLUE_SATURATION,
+                         (unsigned char *)&ctrl->blue_saturation);
+        indycam_read_reg(client, INDYCAM_GAMMA,
+                         (unsigned char *)&ctrl->gamma);
+
+        return 0;
+}
+
+static int indycam_set_controls(struct i2c_client *client,
+                                struct indycam_control *ctrl)
+{
+        unsigned char ctrl_reg;
+
+        indycam_read_reg(client, INDYCAM_CONTROL, &ctrl_reg);
+        if (ctrl->agc != INDYCAM_VALUE_UNCHANGED) {
+                if (ctrl->agc)
+                        ctrl_reg |= INDYCAM_CONTROL_AGCENA;
+                else
+                        ctrl_reg &= ~INDYCAM_CONTROL_AGCENA;
+        }
+        if (ctrl->awb != INDYCAM_VALUE_UNCHANGED) {
+                if (ctrl->awb)
+                        ctrl_reg |= INDYCAM_CONTROL_AWBCTL;
+                else
+                        ctrl_reg &= ~INDYCAM_CONTROL_AWBCTL;
+        }
+        indycam_write_reg(client, INDYCAM_CONTROL, ctrl_reg);
+
+        if (ctrl->shutter >= 0)
+                indycam_write_reg(client, INDYCAM_SHUTTER, ctrl->shutter);
+        if (ctrl->gain >= 0)
+                indycam_write_reg(client, INDYCAM_GAIN, ctrl->gain);
+        if (ctrl->red_balance >= 0)
+                indycam_write_reg(client, INDYCAM_RED_BALANCE,
+                                  ctrl->red_balance);
+        if (ctrl->blue_balance >= 0)
+                indycam_write_reg(client, INDYCAM_BLUE_BALANCE,
+                                  ctrl->blue_balance);
+        if (ctrl->red_saturation >= 0)
+                indycam_write_reg(client, INDYCAM_RED_SATURATION,
+                                  ctrl->red_saturation);
+        if (ctrl->blue_saturation >= 0)
+                indycam_write_reg(client, INDYCAM_BLUE_SATURATION,
+                                  ctrl->blue_saturation);
+        if (ctrl->gamma >= 0)
+                indycam_write_reg(client, INDYCAM_GAMMA, ctrl->gamma);
+
+        return 0;
+}
+
+/* I2C-interface */
+
+static int indycam_attach(struct i2c_adapter *adap, int addr, int kind)
+{
+        int err = 0;
+        struct indycam *camera;
+        struct i2c_client *client;
+
+        printk(KERN_INFO "SGI IndyCam driver version %s\n",
+               INDYCAM_MODULE_VERSION);
+
+        client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+        if (!client)
+                return -ENOMEM;
+        camera = kmalloc(sizeof(struct indycam), GFP_KERNEL);
+        if (!camera) {
+                err = -ENOMEM;
+                goto out_free_client;
+        }
+
+        memset(client, 0, sizeof(struct i2c_client));
+        memset(camera, 0, sizeof(struct indycam));
+
+        client->addr = addr;
+        client->adapter = adap;
+        client->driver = &i2c_driver_indycam;
+        client->flags = 0;
+        strcpy(client->name, "IndyCam client");
+        i2c_set_clientdata(client, camera);
+
+        camera->client = client;
+
+        err = i2c_attach_client(client);
+        if (err)
+                goto out_free_camera;
+
+        camera->version = i2c_smbus_read_byte_data(client, INDYCAM_VERSION);
+        if (camera->version != CAMERA_VERSION_INDY &&
+            camera->version != CAMERA_VERSION_MOOSE) {
+                err = -ENODEV;
+                goto out_detach_client;
+        }
+        printk(KERN_INFO "IndyCam v%d.%d detected\n",
+               INDYCAM_VERSION_MAJOR(camera->version),
+               INDYCAM_VERSION_MINOR(camera->version));
+
+        indycam_regdump(client);
+
+        // initialize
+        err = indycam_write_block(client, 0, sizeof(initseq),
+                                  (unsigned char *)&initseq);
+        if (err) {
+                printk(KERN_ERR "IndyCam initalization failed\n");
+                err = -EIO;
+                goto out_detach_client;
+        }
+
+        indycam_regdump(client);
+
+        // white balance
+        err = indycam_write_reg(client, INDYCAM_CONTROL,
+                          INDYCAM_CONTROL_AGCENA | INDYCAM_CONTROL_AWBCTL);
+        if (err) {
+                printk(KERN_ERR "IndyCam white balance "
+                       "initialization failed\n");
+                err = -EIO;
+                goto out_detach_client;
+        }
+
+        indycam_regdump(client);
+
+        printk(KERN_INFO "IndyCam initialized\n");
+
+        return 0;
+
+out_detach_client:
+        i2c_detach_client(client);
+out_free_camera:
+        kfree(camera);
+out_free_client:
+        kfree(client);
+        return err;
+}
+
+static int indycam_probe(struct i2c_adapter *adap)
+{
+        /* Indy specific crap */
+        if (adap->id == VINO_ADAPTER)
+                return indycam_attach(adap, INDYCAM_ADDR, 0);
+        /* Feel free to add probe here :-) */
+        return -ENODEV;
+}
+
+static int indycam_detach(struct i2c_client *client)
+{
+        struct indycam *camera = i2c_get_clientdata(client);
+
+        i2c_detach_client(client);
+        kfree(camera);
+        kfree(client);
+        return 0;
+}
+
+static int indycam_command(struct i2c_client *client, unsigned int cmd,
+                           void *arg)
+{
+        // struct indycam *camera = i2c_get_clientdata(client);
+
+        /* The old video_decoder interface just isn't enough,
+         * so we'll use some custom commands. */
+        switch (cmd) {
+        case DECODER_GET_CAPABILITIES: {
+                struct video_decoder_capability *cap = arg;
+
+                cap->flags  = VIDEO_DECODER_NTSC;
+                cap->inputs = 1;
+                cap->outputs = 1;
+                break;
+        }
+        case DECODER_GET_STATUS: {
+                int *iarg = arg;
+
+                *iarg = DECODER_STATUS_GOOD | DECODER_STATUS_NTSC |
+                        DECODER_STATUS_COLOR;
+                break;
+        }
+        case DECODER_SET_NORM: {
+                int *iarg = arg;
+
+                switch (*iarg) {
+                case VIDEO_MODE_NTSC:
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        }
+        case DECODER_SET_INPUT: {
+                int *iarg = arg;
+
+                if (*iarg != 0)
+                        return -EINVAL;
+                break;
+        }
+        case DECODER_SET_OUTPUT: {
+                int *iarg = arg;
+
+                if (*iarg != 0)
+                        return -EINVAL;
+                break;
+        }
+        case DECODER_ENABLE_OUTPUT: {
+                /* Always enabled */
+                break;
+        }
+        case DECODER_SET_PICTURE: {
+                // struct video_picture *pic = arg;
+                /* TODO: convert values for indycam_set_controls() */
+                break;
+        }
+        case DECODER_INDYCAM_GET_CONTROLS: {
+                struct indycam_control *ctrl = arg;
+                indycam_get_controls(client, ctrl);
+        }
+        case DECODER_INDYCAM_SET_CONTROLS: {
+                struct indycam_control *ctrl = arg;
+                indycam_set_controls(client, ctrl);
+        }
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct i2c_driver i2c_driver_indycam = {
+        .owner          = THIS_MODULE,
+        .name           = "indycam",
+        .id             = I2C_DRIVERID_INDYCAM,
+        .flags          = I2C_DF_NOTIFY,
+        .attach_adapter = indycam_probe,
+        .detach_client  = indycam_detach,
+        .command        = indycam_command,
+};
+
+static int __init indycam_init(void)
+{
+        return i2c_add_driver(&i2c_driver_indycam);
+}
+
+static void __exit indycam_exit(void)
+{
+        i2c_del_driver(&i2c_driver_indycam);
+}
+
+module_init(indycam_init);
+module_exit(indycam_exit);
diff --git a/drivers/media/video/indycam.h b/drivers/media/video/indycam.h
new file mode 100644
index 000000000000..d9ddb6b79a03
--- /dev/null
+++ b/drivers/media/video/indycam.h
@@ -0,0 +1,112 @@
+/*
+ *  indycam.h - Silicon Graphics IndyCam digital camera driver
+ *
+ *  Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
+ *  Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
+ *
+ *  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.
+ */
+
+#ifndef _INDYCAM_H_
+#define _INDYCAM_H_
+
+/* I2C address for the Guinness Camera */
+#define INDYCAM_ADDR                    0x56
+
+/* Camera version */
+#define CAMERA_VERSION_INDY             0x10    /* v1.0 */
+#define CAMERA_VERSION_MOOSE            0x12    /* v1.2 */
+#define INDYCAM_VERSION_MAJOR(x)        (((x) & 0xf0) >> 4)
+#define INDYCAM_VERSION_MINOR(x)        ((x) & 0x0f)
+
+/* Register bus addresses */
+#define INDYCAM_CONTROL                 0x00
+#define INDYCAM_SHUTTER                 0x01
+#define INDYCAM_GAIN                    0x02
+#define INDYCAM_BRIGHTNESS              0x03 /* read-only */
+#define INDYCAM_RED_BALANCE             0x04
+#define INDYCAM_BLUE_BALANCE            0x05
+#define INDYCAM_RED_SATURATION          0x06
+#define INDYCAM_BLUE_SATURATION         0x07
+#define INDYCAM_GAMMA                   0x08
+#define INDYCAM_VERSION                 0x0e /* read-only */
+#define INDYCAM_RESET                   0x0f /* write-only */
+
+#define INDYCAM_LED                     0x46
+#define INDYCAM_ORIENTATION             0x47
+#define INDYCAM_BUTTON                  0x48
+
+/* Field definitions of registers */
+#define INDYCAM_CONTROL_AGCENA          (1<<0) /* automatic gain control */
+#define INDYCAM_CONTROL_AWBCTL          (1<<1) /* automatic white balance */
+                                                /* 2-3 are reserved */
+#define INDYCAM_CONTROL_EVNFLD          (1<<4)  /* read-only */
+
+#define INDYCAM_SHUTTER_10000           0x02    /* 1/10000 second */
+#define INDYCAM_SHUTTER_4000            0x04    /* 1/4000 second */
+#define INDYCAM_SHUTTER_2000            0x08    /* 1/2000 second */
+#define INDYCAM_SHUTTER_1000            0x10    /* 1/1000 second */
+#define INDYCAM_SHUTTER_500             0x20    /* 1/500 second */
+#define INDYCAM_SHUTTER_250             0x3f    /* 1/250 second */
+#define INDYCAM_SHUTTER_125             0x7e    /* 1/125 second */
+#define INDYCAM_SHUTTER_100             0x9e    /* 1/100 second */
+#define INDYCAM_SHUTTER_60              0x00    /* 1/60 second */
+
+#define INDYCAM_LED_ACTIVE                      0x10
+#define INDYCAM_LED_INACTIVE                    0x30
+#define INDYCAM_ORIENTATION_BOTTOM_TO_TOP       0x40
+#define INDYCAM_BUTTON_RELEASED                 0x10
+
+#define INDYCAM_SHUTTER_MIN             0x00
+#define INDYCAM_SHUTTER_MAX             0xff
+#define INDYCAM_GAIN_MIN                0x00
+#define INDYCAM_GAIN_MAX                0xff
+#define INDYCAM_RED_BALANCE_MIN         0x00 /* the effect is the opposite? */
+#define INDYCAM_RED_BALANCE_MAX         0xff
+#define INDYCAM_BLUE_BALANCE_MIN        0x00 /* the effect is the opposite? */
+#define INDYCAM_BLUE_BALANCE_MAX        0xff
+#define INDYCAM_RED_SATURATION_MIN      0x00
+#define INDYCAM_RED_SATURATION_MAX      0xff
+#define INDYCAM_BLUE_SATURATION_MIN     0x00
+#define INDYCAM_BLUE_SATURATION_MAX     0xff
+#define INDYCAM_GAMMA_MIN               0x00
+#define INDYCAM_GAMMA_MAX               0xff
+
+/* Driver interface definitions */
+
+#define INDYCAM_VALUE_ENABLED           1
+#define INDYCAM_VALUE_DISABLED          0
+#define INDYCAM_VALUE_UNCHANGED         -1
+
+/* When setting controls, a value of -1 leaves the control unchanged. */
+struct indycam_control {
+        int agc;        /* boolean */
+        int awb;        /* boolean */
+        int shutter;
+        int gain;
+        int red_balance;
+        int blue_balance;
+        int red_saturation;
+        int blue_saturation;
+        int gamma;
+};
+
+#define DECODER_INDYCAM_GET_CONTROLS    _IOR('d', 193, struct indycam_control)
+#define DECODER_INDYCAM_SET_CONTROLS    _IOW('d', 194, struct indycam_control)
+
+/* Default values for controls */
+
+#define INDYCAM_AGC_DEFAULT             INDYCAM_VALUE_ENABLED
+#define INDYCAM_AWB_DEFAULT             INDYCAM_VALUE_ENABLED
+
+#define INDYCAM_SHUTTER_DEFAULT         INDYCAM_SHUTTER_60
+#define INDYCAM_GAIN_DEFAULT            0x80
+#define INDYCAM_RED_BALANCE_DEFAULT     0x18
+#define INDYCAM_BLUE_BALANCE_DEFAULT    0xa4
+#define INDYCAM_RED_SATURATION_DEFAULT  0x80
+#define INDYCAM_BLUE_SATURATION_DEFAULT 0xc0
+#define INDYCAM_GAMMA_DEFAULT           0x80
+
+#endif
diff --git a/drivers/media/video/meye.c b/drivers/media/video/meye.c
index fe194012bccf..3f2a882bc20a 100644
--- a/drivers/media/video/meye.c
+++ b/drivers/media/video/meye.c
@@ -37,6 +37,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/vmalloc.h>
+#include <linux/dma-mapping.h>
 
 #include "meye.h"
 #include <linux/meye.h>
@@ -121,7 +122,7 @@ static int ptable_alloc(void)
         memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
 
         /* give only 32 bit DMA addresses */
-        if (dma_set_mask(&meye.mchip_dev->dev, 0xffffffff))
+        if (dma_set_mask(&meye.mchip_dev->dev, DMA_32BIT_MASK))
                 return -1;
 
         meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
diff --git a/drivers/media/video/saa7111.c b/drivers/media/video/saa7111.c
index f18df53d98ff..fe8a5e453969 100644
--- a/drivers/media/video/saa7111.c
+++ b/drivers/media/video/saa7111.c
@@ -42,7 +42,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/saa7114.c b/drivers/media/video/saa7114.c
index e0c70f54f073..d9f50e2f7b92 100644
--- a/drivers/media/video/saa7114.c
+++ b/drivers/media/video/saa7114.c
@@ -45,7 +45,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/saa7185.c b/drivers/media/video/saa7185.c
index e93412f4407c..132aa7943c16 100644
--- a/drivers/media/video/saa7185.c
+++ b/drivers/media/video/saa7185.c
@@ -39,7 +39,6 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 
 #include <linux/videodev.h>
diff --git a/drivers/media/video/saa7191.c b/drivers/media/video/saa7191.c
new file mode 100644
index 000000000000..454f5c1199b4
--- /dev/null
+++ b/drivers/media/video/saa7191.c
@@ -0,0 +1,512 @@
+/*
+ *  saa7191.c - Philips SAA7191 video decoder driver
+ *
+ *  Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
+ *  Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+
+#include <linux/videodev.h>
+#include <linux/video_decoder.h>
+#include <linux/i2c.h>
+
+#include "saa7191.h"
+
+#define SAA7191_MODULE_VERSION "0.0.3"
+
+MODULE_DESCRIPTION("Philips SAA7191 video decoder driver");
+MODULE_VERSION(SAA7191_MODULE_VERSION);
+MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
+MODULE_LICENSE("GPL");
+
+#define VINO_ADAPTER    (I2C_ALGO_SGI | I2C_HW_SGI_VINO)
+
+struct saa7191 {
+        struct i2c_client *client;
+
+        /* the register values are stored here as the actual
+         * I2C-registers are write-only */
+        unsigned char reg[25];
+
+        unsigned char norm;
+        unsigned char input;
+};
+
+static struct i2c_driver i2c_driver_saa7191;
+
+static const unsigned char initseq[] = {
+        0,      /* Subaddress */
+        0x50,   /* SAA7191_REG_IDEL */
+        0x30,   /* SAA7191_REG_HSYB */
+        0x00,   /* SAA7191_REG_HSYS */
+        0xe8,   /* SAA7191_REG_HCLB */
+        0xb6,   /* SAA7191_REG_HCLS */
+        0xf4,   /* SAA7191_REG_HPHI */
+        0x01,   /* SAA7191_REG_LUMA - chrominance trap active (CVBS) */
+        0x00,   /* SAA7191_REG_HUEC */
+        0xf8,   /* SAA7191_REG_CKTQ */
+        0xf8,   /* SAA7191_REG_CKTS */
+        0x90,   /* SAA7191_REG_PLSE */
+        0x90,   /* SAA7191_REG_SESE */
+        0x00,   /* SAA7191_REG_GAIN */
+        0x0c,   /* SAA7191_REG_STDC - not SECAM, slow time constant */
+        0x78,   /* SAA7191_REG_IOCK - chrominance from CVBS, GPSW1 & 2 off */
+        0x99,   /* SAA7191_REG_CTL3 - automatic field detection */
+        0x00,   /* SAA7191_REG_CTL4 */
+        0x2c,   /* SAA7191_REG_CHCV */
+        0x00,   /* unused */
+        0x00,   /* unused */
+        0x34,   /* SAA7191_REG_HS6B */
+        0x0a,   /* SAA7191_REG_HS6S */
+        0xf4,   /* SAA7191_REG_HC6B */
+        0xce,   /* SAA7191_REG_HC6S */
+        0xf4,   /* SAA7191_REG_HP6I */
+};
+
+/* SAA7191 register handling */
+
+static unsigned char saa7191_read_reg(struct i2c_client *client,
+                                      unsigned char reg)
+{
+        return ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg];
+}
+
+static int saa7191_read_status(struct i2c_client *client,
+                               unsigned char *value)
+{
+        int ret;
+
+        ret = i2c_master_recv(client, value, 1);
+        if (ret < 0) {
+                printk(KERN_ERR "SAA7191: saa7191_read_status(): read failed");
+                return ret;
+        }
+
+        return 0;
+}
+
+
+static int saa7191_write_reg(struct i2c_client *client, unsigned char reg,
+                             unsigned char value)
+{
+
+        ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg] = value;
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* the first byte of data must be the first subaddress number (register) */
+static int saa7191_write_block(struct i2c_client *client,
+                               unsigned char length, unsigned char *data)
+{
+        int i;
+        int ret;
+
+        struct saa7191 *decoder = (struct saa7191 *)i2c_get_clientdata(client);
+        for (i = 0; i < (length - 1); i++) {
+                decoder->reg[data[0] + i] = data[i + 1];
+        }
+
+        ret = i2c_master_send(client, data, length);
+        if (ret < 0) {
+                printk(KERN_ERR "SAA7191: saa7191_write_block(): "
+                       "write failed");
+                return ret;
+        }
+
+        return 0;
+}
+
+/* Helper functions */
+
+static int saa7191_set_input(struct i2c_client *client, int input)
+{
+        unsigned char luma = saa7191_read_reg(client, SAA7191_REG_LUMA);
+        unsigned char iock = saa7191_read_reg(client, SAA7191_REG_IOCK);
+        int err;
+
+        switch (input) {
+        case SAA7191_INPUT_COMPOSITE: /* Set Composite input */
+                iock &= ~(SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW1
+                          | SAA7191_IOCK_GPSW2);
+                /* Chrominance trap active */
+                luma &= ~SAA7191_LUMA_BYPS;
+                break;
+        case SAA7191_INPUT_SVIDEO: /* Set S-Video input */
+                iock |= SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW2;
+                /* Chrominance trap bypassed */
+                luma |= SAA7191_LUMA_BYPS;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        err = saa7191_write_reg(client, SAA7191_REG_LUMA, luma);
+        if (err)
+                return -EIO;
+        err = saa7191_write_reg(client, SAA7191_REG_IOCK, iock);
+        if (err)
+                return -EIO;
+
+        return 0;
+}
+
+static int saa7191_set_norm(struct i2c_client *client, int norm)
+{
+        struct saa7191 *decoder = i2c_get_clientdata(client);
+        unsigned char stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
+        unsigned char ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
+        unsigned char chcv = saa7191_read_reg(client, SAA7191_REG_CHCV);
+        int err;
+
+        switch(norm) {
+        case SAA7191_NORM_AUTO: {
+                unsigned char status;
+
+                // does status depend on current norm ?
+                if (saa7191_read_status(client, &status))
+                        return -EIO;
+
+                stdc &= ~SAA7191_STDC_SECS;
+                ctl3 &= ~SAA7191_CTL3_FSEL;
+                ctl3 |= SAA7191_CTL3_AUFD;
+                chcv = (status & SAA7191_STATUS_FIDT)
+                               ? SAA7191_CHCV_NTSC : SAA7191_CHCV_PAL;
+                break;
+        }
+        case SAA7191_NORM_PAL:
+                stdc &= ~SAA7191_STDC_SECS;
+                ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
+                chcv = SAA7191_CHCV_PAL;
+                break;
+        case SAA7191_NORM_NTSC:
+                stdc &= ~SAA7191_STDC_SECS;
+                ctl3 &= ~SAA7191_CTL3_AUFD;
+                ctl3 |= SAA7191_CTL3_FSEL;
+                chcv = SAA7191_CHCV_NTSC;
+                break;
+        case SAA7191_NORM_SECAM:
+                stdc |= SAA7191_STDC_SECS;
+                ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
+                chcv = SAA7191_CHCV_PAL;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
+        if (err)
+                return -EIO;
+        err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
+        if (err)
+                return -EIO;
+        err = saa7191_write_reg(client, SAA7191_REG_CHCV, chcv);
+        if (err)
+                return -EIO;
+
+        decoder->norm = norm;
+
+        return 0;
+}
+
+static int saa7191_get_controls(struct i2c_client *client,
+                                struct saa7191_control *ctrl)
+{
+        unsigned char hue = saa7191_read_reg(client, SAA7191_REG_HUEC);
+        unsigned char stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
+
+        if (hue < 0x80) {
+                hue += 0x80;
+        } else {
+                hue -= 0x80;
+        }
+        ctrl->hue = hue;
+
+        ctrl->vtrc = (stdc & SAA7191_STDC_VTRC)
+                ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
+
+        return 0;
+}
+
+static int saa7191_set_controls(struct i2c_client *client,
+                                struct saa7191_control *ctrl)
+{
+        int err;
+
+        if (ctrl->hue >= 0) {
+                unsigned char hue = ctrl->hue & 0xff;
+                if (hue < 0x80) {
+                        hue += 0x80;
+                } else {
+                        hue -= 0x80;
+                }
+                err = saa7191_write_reg(client, SAA7191_REG_HUEC, hue);
+                if (err)
+                        return -EIO;
+        }
+        if (ctrl->vtrc >= 0) {
+                unsigned char stdc =
+                        saa7191_read_reg(client, SAA7191_REG_STDC);
+
+                if (ctrl->vtrc) {
+                        stdc |= SAA7191_STDC_VTRC;
+                } else {
+                        stdc &= ~SAA7191_STDC_VTRC;
+                }
+
+                err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
+                if (err)
+                        return -EIO;
+        }
+
+        return 0;
+}
+
+/* I2C-interface */
+
+static int saa7191_attach(struct i2c_adapter *adap, int addr, int kind)
+{
+        int err = 0;
+        struct saa7191 *decoder;
+        struct i2c_client *client;
+
+        printk(KERN_INFO "Philips SAA7191 driver version %s\n",
+               SAA7191_MODULE_VERSION);
+
+        client = kmalloc(sizeof(*client), GFP_KERNEL);
+        if (!client)
+                return -ENOMEM;
+        decoder = kmalloc(sizeof(*decoder), GFP_KERNEL);
+        if (!decoder) {
+                err = -ENOMEM;
+                goto out_free_client;
+        }
+
+        memset(client, 0, sizeof(struct i2c_client));
+        memset(decoder, 0, sizeof(struct saa7191));
+
+        client->addr = addr;
+        client->adapter = adap;
+        client->driver = &i2c_driver_saa7191;
+        client->flags = 0;
+        strcpy(client->name, "saa7191 client");
+        i2c_set_clientdata(client, decoder);
+
+        decoder->client = client;
+
+        err = i2c_attach_client(client);
+        if (err)
+                goto out_free_decoder;
+
+        decoder->input = SAA7191_INPUT_COMPOSITE;
+        decoder->norm = SAA7191_NORM_AUTO;
+
+        err = saa7191_write_block(client, sizeof(initseq),
+                                  (unsigned char *)initseq);
+        if (err) {
+                printk(KERN_ERR "SAA7191 initialization failed\n");
+                goto out_detach_client;
+        }
+
+        printk(KERN_INFO "SAA7191 initialized\n");
+
+        return 0;
+
+out_detach_client:
+        i2c_detach_client(client);
+out_free_decoder:
+        kfree(decoder);
+out_free_client:
+        kfree(client);
+        return err;
+}
+
+static int saa7191_probe(struct i2c_adapter *adap)
+{
+        /* Always connected to VINO */
+        if (adap->id == VINO_ADAPTER)
+                return saa7191_attach(adap, SAA7191_ADDR, 0);
+        /* Feel free to add probe here :-) */
+        return -ENODEV;
+}
+
+static int saa7191_detach(struct i2c_client *client)
+{
+        struct saa7191 *decoder = i2c_get_clientdata(client);
+
+        i2c_detach_client(client);
+        kfree(decoder);
+        kfree(client);
+        return 0;
+}
+
+static int saa7191_command(struct i2c_client *client, unsigned int cmd,
+                           void *arg)
+{
+        struct saa7191 *decoder = i2c_get_clientdata(client);
+
+        switch (cmd) {
+        case DECODER_GET_CAPABILITIES: {
+                struct video_decoder_capability *cap = arg;
+
+                cap->flags  = VIDEO_DECODER_PAL | VIDEO_DECODER_NTSC |
+                              VIDEO_DECODER_SECAM | VIDEO_DECODER_AUTO;
+                cap->inputs = (client->adapter->id == VINO_ADAPTER) ? 2 : 1;
+                cap->outputs = 1;
+                break;
+        }
+        case DECODER_GET_STATUS: {
+                int *iarg = arg;
+                unsigned char status;
+                int res = 0;
+
+                if (saa7191_read_status(client, &status)) {
+                        return -EIO;
+                }
+                if ((status & SAA7191_STATUS_HLCK) == 0)
+                        res |= DECODER_STATUS_GOOD;
+                if (status & SAA7191_STATUS_CODE)
+                        res |= DECODER_STATUS_COLOR;
+                switch (decoder->norm) {
+                case SAA7191_NORM_NTSC:
+                        res |= DECODER_STATUS_NTSC;
+                        break;
+                case SAA7191_NORM_PAL:
+                        res |= DECODER_STATUS_PAL;
+                        break;
+                case SAA7191_NORM_SECAM:
+                        res |= DECODER_STATUS_SECAM;
+                        break;
+                case SAA7191_NORM_AUTO:
+                default:
+                        if (status & SAA7191_STATUS_FIDT)
+                                res |= DECODER_STATUS_NTSC;
+                        else
+                                res |= DECODER_STATUS_PAL;
+                        break;
+                }
+                *iarg = res;
+                break;
+        }
+        case DECODER_SET_NORM: {
+                int *iarg = arg;
+
+                switch (*iarg) {
+                case VIDEO_MODE_AUTO:
+                        return saa7191_set_norm(client, SAA7191_NORM_AUTO);
+                case VIDEO_MODE_PAL:
+                        return saa7191_set_norm(client, SAA7191_NORM_PAL);
+                case VIDEO_MODE_NTSC:
+                        return saa7191_set_norm(client, SAA7191_NORM_NTSC);
+                case VIDEO_MODE_SECAM:
+                        return saa7191_set_norm(client, SAA7191_NORM_SECAM);
+                default:
+                        return -EINVAL;
+                }
+                break;
+        }
+        case DECODER_SET_INPUT: {
+                int *iarg = arg;
+
+                switch (client->adapter->id) {
+                case VINO_ADAPTER:
+                        return saa7191_set_input(client, *iarg);
+                default:
+                        if (*iarg != 0)
+                                return -EINVAL;
+                }
+                break;
+        }
+        case DECODER_SET_OUTPUT: {
+                int *iarg = arg;
+
+                /* not much choice of outputs */
+                if (*iarg != 0)
+                        return -EINVAL;
+                break;
+        }
+        case DECODER_ENABLE_OUTPUT: {
+                /* Always enabled */
+                break;
+        }
+        case DECODER_SET_PICTURE: {
+                struct video_picture *pic = arg;
+                unsigned val;
+                int err;
+
+                val = (pic->hue >> 8) - 0x80;
+                err = saa7191_write_reg(client, SAA7191_REG_HUEC, val);
+                if (err)
+                        return -EIO;
+                break;
+        }
+        case DECODER_SAA7191_GET_STATUS: {
+                struct saa7191_status *status = arg;
+                unsigned char status_reg;
+
+                if (saa7191_read_status(client, &status_reg))
+                        return -EIO;
+                status->signal = ((status_reg & SAA7191_STATUS_HLCK) == 0)
+                        ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
+                status->ntsc = (status_reg & SAA7191_STATUS_FIDT)
+                        ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
+                status->color = (status_reg & SAA7191_STATUS_CODE)
+                        ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
+
+                status->input = decoder->input;
+                status->norm = decoder->norm;
+        }
+        case DECODER_SAA7191_SET_NORM: {
+                int *norm = arg;
+                return saa7191_set_norm(client, *norm);
+        }
+        case DECODER_SAA7191_GET_CONTROLS: {
+                struct saa7191_control *ctrl = arg;
+                return saa7191_get_controls(client, ctrl);
+        }
+        case DECODER_SAA7191_SET_CONTROLS: {
+                struct saa7191_control *ctrl = arg;
+                return saa7191_set_controls(client, ctrl);
+        }
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct i2c_driver i2c_driver_saa7191 = {
+        .owner          = THIS_MODULE,
+        .name           = "saa7191",
+        .id             = I2C_DRIVERID_SAA7191,
+        .flags          = I2C_DF_NOTIFY,
+        .attach_adapter = saa7191_probe,
+        .detach_client  = saa7191_detach,
+        .command        = saa7191_command
+};
+
+static int saa7191_init(void)
+{
+        return i2c_add_driver(&i2c_driver_saa7191);
+}
+
+static void saa7191_exit(void)
+{
+        i2c_del_driver(&i2c_driver_saa7191);
+}
+
+module_init(saa7191_init);
+module_exit(saa7191_exit);
diff --git a/drivers/media/video/saa7191.h b/drivers/media/video/saa7191.h
new file mode 100644
index 000000000000..272045031435
--- /dev/null
+++ b/drivers/media/video/saa7191.h
@@ -0,0 +1,139 @@
+/*
+ *  saa7191.h - Philips SAA7191 video decoder driver
+ *
+ *  Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
+ *  Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
+ *
+ *  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.
+ */
+
+#ifndef _SAA7191_H_
+#define _SAA7191_H_
+
+/* Philips SAA7191 DMSD I2C bus address */
+#define SAA7191_ADDR            0x8a
+
+/* Register subaddresses. */
+#define SAA7191_REG_IDEL        0x00
+#define SAA7191_REG_HSYB        0x01
+#define SAA7191_REG_HSYS        0x02
+#define SAA7191_REG_HCLB        0x03
+#define SAA7191_REG_HCLS        0x04
+#define SAA7191_REG_HPHI        0x05
+#define SAA7191_REG_LUMA        0x06
+#define SAA7191_REG_HUEC        0x07
+#define SAA7191_REG_CKTQ        0x08
+#define SAA7191_REG_CKTS        0x09
+#define SAA7191_REG_PLSE        0x0a
+#define SAA7191_REG_SESE        0x0b
+#define SAA7191_REG_GAIN        0x0c
+#define SAA7191_REG_STDC        0x0d
+#define SAA7191_REG_IOCK        0x0e
+#define SAA7191_REG_CTL3        0x0f
+#define SAA7191_REG_CTL4        0x10
+#define SAA7191_REG_CHCV        0x11
+#define SAA7191_REG_HS6B        0x14
+#define SAA7191_REG_HS6S        0x15
+#define SAA7191_REG_HC6B        0x16
+#define SAA7191_REG_HC6S        0x17
+#define SAA7191_REG_HP6I        0x18
+#define SAA7191_REG_STATUS      0xff    /* not really a subaddress */
+
+/* Status Register definitions */
+#define SAA7191_STATUS_CODE     0x01    /* color detected flag */
+#define SAA7191_STATUS_FIDT     0x20    /* format type NTSC/PAL */
+#define SAA7191_STATUS_HLCK     0x40    /* PLL unlocked/locked */
+#define SAA7191_STATUS_STTC     0x80    /* tv/vtr time constant */
+
+/* Luminance Control Register definitions */
+#define SAA7191_LUMA_BYPS       0x80
+
+/* Chroma Gain Control Settings Register definitions */
+/* 0=automatic colour-killer enabled, 1=forced colour on */
+#define SAA7191_GAIN_COLO       0x80
+
+/* Standard/Mode Control Register definitions */
+/* tv/vtr mode bit: 0=TV mode (slow time constant),
+ * 1=VTR mode (fast time constant) */
+#define SAA7191_STDC_VTRC       0x80
+/* SECAM mode bit: 0=other standards, 1=SECAM */
+#define SAA7191_STDC_SECS       0x01
+/* the bit fields above must be or'd with this value */
+#define SAA7191_STDC_VALUE      0x0c
+
+/* I/O and Clock Control Register definitions */
+/* horizontal clock PLL: 0=PLL closed,
+ * 1=PLL circuit open and horizontal freq fixed */
+#define SAA7191_IOCK_HPLL       0x80
+/* S-VHS bit (chrominance from CVBS or from chrominance input):
+ * 0=controlled by BYPS-bit, 1=from chrominance input */
+#define SAA7191_IOCK_CHRS       0x04
+/* general purpose switch 2
+ * VINO-specific: 0=used with CVBS, 1=used with S-Video */
+#define SAA7191_IOCK_GPSW2      0x02
+/* general purpose switch 1 */
+/* VINO-specific: 0=always, 1=not used!*/
+#define SAA7191_IOCK_GPSW1      0x01
+
+/* Miscellaneous Control #1 Register definitions */
+/* automatic field detection (50/60Hz standard) */
+#define SAA7191_CTL3_AUFD       0x80
+/* field select: (if AUFD=0)
+ * 0=50Hz (625 lines), 1=60Hz (525 lines) */
+#define SAA7191_CTL3_FSEL       0x40
+/* the bit fields above must be or'd with this value */
+#define SAA7191_CTL3_VALUE      0x19
+
+/* Chrominance Gain Control Register definitions
+ * (nominal value for UV CCIR level) */
+#define SAA7191_CHCV_NTSC       0x2c
+#define SAA7191_CHCV_PAL        0x59
+
+/* Driver interface definitions */
+#define SAA7191_INPUT_COMPOSITE 0
+#define SAA7191_INPUT_SVIDEO    1
+
+#define SAA7191_NORM_AUTO       0
+#define SAA7191_NORM_PAL        1
+#define SAA7191_NORM_NTSC       2
+#define SAA7191_NORM_SECAM      3
+
+#define SAA7191_VALUE_ENABLED           1
+#define SAA7191_VALUE_DISABLED          0
+#define SAA7191_VALUE_UNCHANGED         -1
+
+struct saa7191_status {
+        /* 0=no signal, 1=signal active*/
+        int signal;
+        /* 0=50hz (pal) signal, 1=60hz (ntsc) signal */
+        int ntsc;
+        /* 0=no color detected, 1=color detected */
+        int color;
+
+        /* current SAA7191_INPUT_ */
+        int input;
+        /* current SAA7191_NORM_ */
+        int norm;
+};
+
+#define SAA7191_HUE_MIN         0x00
+#define SAA7191_HUE_MAX         0xff
+#define SAA7191_HUE_DEFAULT     0x80
+
+#define SAA7191_VTRC_MIN        0x00
+#define SAA7191_VTRC_MAX        0x01
+#define SAA7191_VTRC_DEFAULT    0x00
+
+struct saa7191_control {
+        int hue;
+        int vtrc;
+};
+
+#define DECODER_SAA7191_GET_STATUS      _IOR('d', 195, struct saa7191_status)
+#define DECODER_SAA7191_SET_NORM        _IOW('d', 196, int)
+#define DECODER_SAA7191_GET_CONTROLS    _IOR('d', 197, struct saa7191_control)
+#define DECODER_SAA7191_SET_CONTROLS    _IOW('d', 198, struct saa7191_control)
+
+#endif
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index 76e8681d65c6..d8a0f763ca10 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -1,80 +1,606 @@
 /*
- * (incomplete) Driver for the VINO (Video In No Out) system found in SGI Indys.
+ * Driver for the VINO (Video In No Out) system found in SGI Indys.
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License version 2 as published by the Free Software Foundation.
  *
+ * Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
+ *
+ * Based on the previous version of the driver for 2.4 kernels by:
  * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
  */
 
-#include <linux/module.h>
+/*
+ * TODO:
+ * - remove "hacks" from memory allocation code and implement nopage()
+ * - check decimation, calculating and reporting image size when
+ *   using decimation
+ * - check vino_acquire_input(), vino_set_input() and channel
+ *   ownership handling
+ * - report VINO error-interrupts via ioctls ?
+ * - implement picture controls (all implemented?)
+ * - use macros for boolean values (?)
+ * - implement user mode buffers and overlay (?)
+ */
+
 #include <linux/init.h>
-#include <linux/types.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/wrapper.h>
-#include <linux/errno.h>
-#include <linux/irq.h>
+#include <linux/module.h>
 #include <linux/delay.h>
-#include <linux/videodev.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/time.h>
+#include <linux/moduleparam.h>
+
+#ifdef CONFIG_KMOD
+#include <linux/kmod.h>
+#endif
+
 #include <linux/i2c.h>
 #include <linux/i2c-algo-sgi.h>
 
-#include <asm/addrspace.h>
-#include <asm/system.h>
-#include <asm/bootinfo.h>
-#include <asm/pgtable.h>
+#include <linux/videodev.h>
+#include <linux/videodev2.h>
+#include <linux/video_decoder.h>
+
 #include <asm/paccess.h>
 #include <asm/io.h>
 #include <asm/sgi/ip22.h>
-#include <asm/sgi/hpc3.h>
 #include <asm/sgi/mc.h>
 
 #include "vino.h"
+#include "saa7191.h"
+#include "indycam.h"
+
+/* Uncomment the following line to get lots and lots of (mostly useless)
+ * debug info.
+ * Note that the debug output also slows down the driver significantly */
+// #define VINO_DEBUG
+
+#define VINO_MODULE_VERSION "0.0.3"
+#define VINO_VERSION_CODE KERNEL_VERSION(0, 0, 3)
+
+MODULE_DESCRIPTION("SGI VINO Video4Linux2 driver");
+MODULE_VERSION(VINO_MODULE_VERSION);
+MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
+MODULE_LICENSE("GPL");
 
-/* debugging? */
-#if 1
-#define DEBUG(x...)     printk(x);
+#define mem_map_reserve(p) set_bit(PG_reserved, &((p)->flags))
+#define mem_map_unreserve(p) clear_bit(PG_reserved, &((p)->flags))
+
+#ifdef VINO_DEBUG
+#define dprintk(x...) printk("VINO: " x);
 #else
-#define DEBUG(x...)
+#define dprintk(x...)
 #endif
 
+#define VINO_NO_CHANNEL                 0
+#define VINO_CHANNEL_A                  1
+#define VINO_CHANNEL_B                  2
+
+#define VINO_PAL_WIDTH                  768
+#define VINO_PAL_HEIGHT                 576
+#define VINO_NTSC_WIDTH                 640
+#define VINO_NTSC_HEIGHT                480
+
+#define VINO_MIN_WIDTH                  32
+#define VINO_MIN_HEIGHT                 32
+
+#define VINO_CLIPPING_START_ODD_D1      1
+#define VINO_CLIPPING_START_ODD_PAL     1
+#define VINO_CLIPPING_START_ODD_NTSC    1
+
+#define VINO_CLIPPING_START_EVEN_D1     2
+#define VINO_CLIPPING_START_EVEN_PAL    2
+#define VINO_CLIPPING_START_EVEN_NTSC   2
+
+#define VINO_INPUT_CHANNEL_COUNT        3
+
+#define VINO_INPUT_NONE                 -1
+#define VINO_INPUT_COMPOSITE            0
+#define VINO_INPUT_SVIDEO               1
+#define VINO_INPUT_D1                   2
+
+#define VINO_PAGE_RATIO                 (PAGE_SIZE / VINO_PAGE_SIZE)
+
+#define VINO_FIFO_THRESHOLD_DEFAULT     512
+
+/*#define VINO_FRAMEBUFFER_SIZE         (VINO_PAL_WIDTH * VINO_PAL_HEIGHT * 4 \
+  + 2 * PAGE_SIZE)*/
+#define VINO_FRAMEBUFFER_SIZE           ((VINO_PAL_WIDTH \
+                                          * VINO_PAL_HEIGHT * 4 \
+                                          + 3 * PAGE_SIZE) & ~(PAGE_SIZE - 1))
+
+#define VINO_FRAMEBUFFER_MAX_COUNT      8
+
+#define VINO_FRAMEBUFFER_UNUSED         0
+#define VINO_FRAMEBUFFER_IN_USE         1
+#define VINO_FRAMEBUFFER_READY          2
+
+#define VINO_QUEUE_ERROR                -1
+#define VINO_QUEUE_MAGIC                0x20050125
+
+#define VINO_MEMORY_NONE                0
+#define VINO_MEMORY_MMAP                1
+#define VINO_MEMORY_USERPTR             2
+
+#define VINO_DUMMY_DESC_COUNT           4
+#define VINO_DESC_FETCH_DELAY           5       /* microseconds */
+
+/* the number is the index for vino_data_formats */
+#define VINO_DATA_FMT_NONE              -1
+#define VINO_DATA_FMT_GREY              0
+#define VINO_DATA_FMT_RGB332            1
+#define VINO_DATA_FMT_RGB32             2
+#define VINO_DATA_FMT_YUV               3
+//#define VINO_DATA_FMT_RGB24           4
+
+#define VINO_DATA_FMT_COUNT             4
+
+#define VINO_DATA_NORM_NONE             -1
+#define VINO_DATA_NORM_NTSC             0
+#define VINO_DATA_NORM_PAL              1
+#define VINO_DATA_NORM_SECAM            2
+#define VINO_DATA_NORM_D1               3
+/* The following is a special entry that can be used to
+ * autodetect the norm. */
+#define VINO_DATA_NORM_AUTO             0xff
+
+#define VINO_DATA_NORM_COUNT            4
 
-/* VINO ASIC registers */
-struct sgi_vino *vino;
+/* Internal data structure definitions */
 
-static const char *vinostr = "VINO IndyCam/TV";
-static int threshold_a = 512;
-static int threshold_b = 512;
+struct vino_input {
+        char *name;
+        v4l2_std_id std;
+};
+
+struct vino_clipping {
+        unsigned int left, right, top, bottom;
+};
+
+struct vino_data_format {
+        /* the description */
+        char *description;
+        /* bytes per pixel */
+        unsigned int bpp;
+        /* V4L2 fourcc code */
+        __u32 pixelformat;
+        /* V4L2 colorspace (duh!) */
+        enum v4l2_colorspace colorspace;
+};
+
+struct vino_data_norm {
+        char *description;
+        unsigned int width, height;
+        struct vino_clipping odd;
+        struct vino_clipping even;
+
+        v4l2_std_id std;
+        unsigned int fps_min, fps_max;
+        __u32 framelines;
+};
+
+struct vino_descriptor_table {
+        /* the number of PAGE_SIZE sized pages in the buffer */
+        unsigned int page_count;
+        /* virtual (kmalloc'd) pointers to the actual data
+         * (in PAGE_SIZE chunks, used with mmap streaming) */
+        unsigned long *virtual;
+
+        /* cpu address for the VINO descriptor table
+         * (contains DMA addresses, VINO_PAGE_SIZE chunks) */
+        unsigned long *dma_cpu;
+        /* dma address for the VINO descriptor table
+         * (contains DMA addresses, VINO_PAGE_SIZE chunks) */
+        dma_addr_t dma;
+};
+
+struct vino_framebuffer {
+        /* identifier nubmer */
+        unsigned int id;
+        /* the length of the whole buffer */
+        unsigned int size;
+        /* the length of actual data in buffer */
+        unsigned int data_size;
+        /* the data format */
+        unsigned int data_format;
+        /* the state of buffer data */
+        unsigned int state;
+        /* is the buffer mapped in user space? */
+        unsigned int map_count;
+        /* memory offset for mmap() */
+        unsigned int offset;
+        /* frame counter */
+        unsigned int frame_counter;
+        /* timestamp (written when image capture finishes) */
+        struct timeval timestamp;
+
+        struct vino_descriptor_table desc_table;
+
+        spinlock_t state_lock;
+};
 
-struct vino_device {
-        struct video_device vdev;
-#define VINO_CHAN_A             1
-#define VINO_CHAN_B             2
-        int chan;
+struct vino_framebuffer_fifo {
+        unsigned int length;
+
+        unsigned int used;
+        unsigned int head;
+        unsigned int tail;
+
+        unsigned int data[VINO_FRAMEBUFFER_MAX_COUNT];
+};
+
+struct vino_framebuffer_queue {
+        unsigned int magic;
+
+        /* VINO_MEMORY_NONE, VINO_MEMORY_MMAP or VINO_MEMORY_USERPTR */
+        unsigned int type;
+        unsigned int length;
+
+        /* data field of in and out contain index numbers for buffer */
+        struct vino_framebuffer_fifo in;
+        struct vino_framebuffer_fifo out;
+
+        struct vino_framebuffer *buffer[VINO_FRAMEBUFFER_MAX_COUNT];
+
+        spinlock_t queue_lock;
+        struct semaphore queue_sem;
+        wait_queue_head_t frame_wait_queue;
+};
+
+struct vino_channel_settings {
+        unsigned int channel;
+
+        int input;
+        unsigned int data_format;
+        unsigned int data_norm;
+        struct vino_clipping clipping;
+        unsigned int decimation;
+        unsigned int line_size;
+        unsigned int alpha;
+        unsigned int fps;
+        unsigned int framert_reg;
+
+        unsigned int fifo_threshold;
+
+        struct vino_framebuffer_queue fb_queue;
+
+        /* number of the current field */
+        unsigned int field;
+
+        /* read in progress */
+        int reading;
+        /* streaming is active */
+        int streaming;
+        /* the driver is currently processing the queue */
+        int capturing;
+
+        struct semaphore sem;
+        spinlock_t capture_lock;
+
+        unsigned int users;
+
+        /* V4L support */
+        struct video_device *v4l_device;
 };
 
 struct vino_client {
+        /* the channel which owns this client:
+         * VINO_NO_CHANNEL, VINO_CHANNEL_A or VINO_CHANNEL_B */
+        unsigned int owner;
         struct i2c_client *driver;
-        int owner;
 };
 
-struct vino_video {
-        struct vino_device chA;
-        struct vino_device chB;
+struct vino_settings {
+        struct vino_channel_settings a;
+        struct vino_channel_settings b;
 
         struct vino_client decoder;
         struct vino_client camera;
 
-        struct semaphore input_lock;
+        /* a lock for vino register access */
+        spinlock_t vino_lock;
+        /* a lock for channel input changes */
+        spinlock_t input_lock;
 
-        /* Loaded into VINO descriptors to clear End Of Descriptors table
-         * interupt condition */
         unsigned long dummy_page;
-        unsigned int dummy_buf[4] __attribute__((aligned(8)));
+        struct vino_descriptor_table dummy_desc_table;
 };
 
-static struct vino_video *Vino;
+/* Module parameters */
+
+/*
+ * Using vino_pixel_conversion the ARGB32-format pixels supplied
+ * by the VINO chip can be converted to more common formats
+ * like RGBA32 (or probably RGB24 in the future). This way we
+ * can give out data that can be specified correctly with
+ * the V4L2-definitions.
+ *
+ * The pixel format is specified as RGBA32 when no conversion
+ * is used.
+ *
+ * Note that this only affects the 32-bit bit depth.
+ *
+ * Use non-zero value to enable conversion.
+ */
+static int vino_pixel_conversion = 0;
+module_param_named(pixelconv, vino_pixel_conversion, int, 0);
+MODULE_PARM_DESC(pixelconv,
+                 "enable pixel conversion (non-zero value enables)");
+
+/* Internal data structures */
+
+static struct sgi_vino *vino;
+
+static struct vino_settings *vino_drvdata;
+
+static const char *vino_driver_name = "vino";
+static const char *vino_driver_description = "SGI VINO";
+static const char *vino_bus_name = "GIO64 bus";
+static const char *vino_v4l_device_name_a = "SGI VINO Channel A";
+static const char *vino_v4l_device_name_b = "SGI VINO Channel B";
+
+static const struct vino_input vino_inputs[] = {
+        {
+                .name           = "Composite",
+                .std            = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
+        },{
+                .name           = "S-Video",
+                .std            = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
+        },{
+                .name           = "D1 (IndyCam)",
+                .std            = V4L2_STD_NTSC,
+        }
+};
+
+static const struct vino_data_format vino_data_formats[] = {
+        {
+                .description    = "8-bit greyscale",
+                .bpp            = 1,
+                .pixelformat    = V4L2_PIX_FMT_GREY,
+                .colorspace     = V4L2_COLORSPACE_SMPTE170M,
+        },{
+                .description    = "8-bit dithered RGB 3-3-2",
+                .bpp            = 1,
+                .pixelformat    = V4L2_PIX_FMT_RGB332,
+                .colorspace     = V4L2_COLORSPACE_SRGB,
+        },{
+                .description    = "32-bit RGB",
+                .bpp            = 4,
+                .pixelformat    = V4L2_PIX_FMT_RGB32,
+                .colorspace     = V4L2_COLORSPACE_SRGB,
+        },{
+                .description    = "YUV 4:2:2",
+                .bpp            = 4,
+                .pixelformat    = V4L2_PIX_FMT_YUYV, // XXX: swapped?
+                .colorspace     = V4L2_COLORSPACE_SMPTE170M,
+        }/*,{
+                .description    = "24-bit RGB",
+                .bpp            = 3,
+                .pixelformat    = V4L2_PIX_FMT_RGB24,
+                .colorspace     = V4L2_COLORSPACE_SRGB,
+                }*/
+};
+
+static const struct vino_data_norm vino_data_norms[] = {
+        {
+                .description    = "NTSC",
+                .std            = V4L2_STD_NTSC,
+                .fps_min        = 6,
+                .fps_max        = 30,
+                .framelines     = 525,
+                .width          = VINO_NTSC_WIDTH,
+                .height         = VINO_NTSC_HEIGHT,
+                .odd            = {
+                        .top    = VINO_CLIPPING_START_ODD_NTSC,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_ODD_NTSC
+                        + VINO_NTSC_HEIGHT / 2 - 1,
+                        .right  = VINO_NTSC_WIDTH,
+                },
+                .even           = {
+                        .top    = VINO_CLIPPING_START_EVEN_NTSC,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_EVEN_NTSC
+                        + VINO_NTSC_HEIGHT / 2 - 1,
+                        .right  = VINO_NTSC_WIDTH,
+                },
+        },{
+                .description    = "PAL",
+                .std            = V4L2_STD_PAL,
+                .fps_min        = 5,
+                .fps_max        = 25,
+                .framelines     = 625,
+                .width          = VINO_PAL_WIDTH,
+                .height         = VINO_PAL_HEIGHT,
+                .odd            = {
+                        .top    = VINO_CLIPPING_START_ODD_PAL,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_ODD_PAL
+                        + VINO_PAL_HEIGHT / 2 - 1,
+                        .right  = VINO_PAL_WIDTH,
+                },
+                .even           = {
+                        .top    = VINO_CLIPPING_START_EVEN_PAL,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_EVEN_PAL
+                        + VINO_PAL_HEIGHT / 2 - 1,
+                        .right  = VINO_PAL_WIDTH,
+                },
+        },{
+                .description    = "SECAM",
+                .std            = V4L2_STD_SECAM,
+                .fps_min        = 5,
+                .fps_max        = 25,
+                .framelines     = 625,
+                .width          = VINO_PAL_WIDTH,
+                .height         = VINO_PAL_HEIGHT,
+                .odd            = {
+                        .top    = VINO_CLIPPING_START_ODD_PAL,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_ODD_PAL
+                        + VINO_PAL_HEIGHT / 2 - 1,
+                        .right  = VINO_PAL_WIDTH,
+                },
+                .even           = {
+                        .top    = VINO_CLIPPING_START_EVEN_PAL,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_EVEN_PAL
+                        + VINO_PAL_HEIGHT / 2 - 1,
+                        .right  = VINO_PAL_WIDTH,
+                },
+        },{
+                .description    = "NTSC (D1 input)",
+                .std            = V4L2_STD_NTSC,
+                .fps_min        = 6,
+                .fps_max        = 30,
+                .framelines     = 525,
+                .width          = VINO_NTSC_WIDTH,
+                .height         = VINO_NTSC_HEIGHT,
+                .odd            = {
+                        .top    = VINO_CLIPPING_START_ODD_D1,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_ODD_D1
+                        + VINO_NTSC_HEIGHT / 2 - 1,
+                        .right  = VINO_NTSC_WIDTH,
+                },
+                .even           = {
+                        .top    = VINO_CLIPPING_START_EVEN_D1,
+                        .left   = 0,
+                        .bottom = VINO_CLIPPING_START_EVEN_D1
+                        + VINO_NTSC_HEIGHT / 2 - 1,
+                        .right  = VINO_NTSC_WIDTH,
+                },
+        }
+};
+
+#define VINO_INDYCAM_V4L2_CONTROL_COUNT         9
+
+struct v4l2_queryctrl vino_indycam_v4l2_controls[] = {
+        {
+                .id = V4L2_CID_AUTOGAIN,
+                .type = V4L2_CTRL_TYPE_BOOLEAN,
+                .name = "Automatic Gain Control",
+                .minimum = 0,
+                .maximum = 1,
+                .step = 1,
+                .default_value = INDYCAM_AGC_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_AUTO_WHITE_BALANCE,
+                .type = V4L2_CTRL_TYPE_BOOLEAN,
+                .name = "Automatic White Balance",
+                .minimum = 0,
+                .maximum = 1,
+                .step = 1,
+                .default_value = INDYCAM_AWB_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_GAIN,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Gain",
+                .minimum = INDYCAM_GAIN_MIN,
+                .maximum = INDYCAM_GAIN_MAX,
+                .step = 1,
+                .default_value = INDYCAM_GAIN_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_PRIVATE_BASE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Red Saturation",
+                .minimum = INDYCAM_RED_SATURATION_MIN,
+                .maximum = INDYCAM_RED_SATURATION_MAX,
+                .step = 1,
+                .default_value = INDYCAM_RED_SATURATION_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_PRIVATE_BASE + 1,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Blue Saturation",
+                .minimum = INDYCAM_BLUE_SATURATION_MIN,
+                .maximum = INDYCAM_BLUE_SATURATION_MAX,
+                .step = 1,
+                .default_value = INDYCAM_BLUE_SATURATION_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_RED_BALANCE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Red Balance",
+                .minimum = INDYCAM_RED_BALANCE_MIN,
+                .maximum = INDYCAM_RED_BALANCE_MAX,
+                .step = 1,
+                .default_value = INDYCAM_RED_BALANCE_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_BLUE_BALANCE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Blue Balance",
+                .minimum = INDYCAM_BLUE_BALANCE_MIN,
+                .maximum = INDYCAM_BLUE_BALANCE_MAX,
+                .step = 1,
+                .default_value = INDYCAM_BLUE_BALANCE_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_EXPOSURE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Shutter Control",
+                .minimum = INDYCAM_SHUTTER_MIN,
+                .maximum = INDYCAM_SHUTTER_MAX,
+                .step = 1,
+                .default_value = INDYCAM_SHUTTER_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_GAMMA,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Gamma",
+                .minimum = INDYCAM_GAMMA_MIN,
+                .maximum = INDYCAM_GAMMA_MAX,
+                .step = 1,
+                .default_value = INDYCAM_GAMMA_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        }
+};
+
+#define VINO_SAA7191_V4L2_CONTROL_COUNT         2
+
+struct v4l2_queryctrl vino_saa7191_v4l2_controls[] = {
+        {
+                .id = V4L2_CID_HUE,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+                .name = "Hue",
+                .minimum = SAA7191_HUE_MIN,
+                .maximum = SAA7191_HUE_MAX,
+                .step = 1,
+                .default_value = SAA7191_HUE_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        },{
+                .id = V4L2_CID_PRIVATE_BASE,
+                .type = V4L2_CTRL_TYPE_BOOLEAN,
+                .name = "VTR Time Constant",
+                .minimum = SAA7191_VTRC_MIN,
+                .maximum = SAA7191_VTRC_MAX,
+                .step = 1,
+                .default_value = SAA7191_VTRC_DEFAULT,
+                .flags = 0,
+                .reserved = { 0, 0 },
+        }
+};
+
+/* VINO I2C bus functions */
 
 unsigned i2c_vino_getctrl(void *data)
 {
@@ -112,49 +638,49 @@ static struct i2c_algo_sgi_data i2c_sgi_vino_data =
  */
 static int i2c_vino_client_reg(struct i2c_client *client)
 {
-        int res = 0;
+        int ret = 0;
 
-        down(&Vino->input_lock);
+        spin_lock(&vino_drvdata->input_lock);
         switch (client->driver->id) {
         case I2C_DRIVERID_SAA7191:
-                if (Vino->decoder.driver)
-                        res = -EBUSY;
+                if (vino_drvdata->decoder.driver)
+                        ret = -EBUSY;
                 else
-                        Vino->decoder.driver = client;
+                        vino_drvdata->decoder.driver = client;
                 break;
         case I2C_DRIVERID_INDYCAM:
-                if (Vino->camera.driver)
-                        res = -EBUSY;
+                if (vino_drvdata->camera.driver)
+                        ret = -EBUSY;
                 else
-                        Vino->camera.driver = client;
+                        vino_drvdata->camera.driver = client;
                 break;
         default:
-                res = -ENODEV;
+                ret = -ENODEV;
         }
-        up(&Vino->input_lock);
+        spin_unlock(&vino_drvdata->input_lock);
 
-        return res;
+        return ret;
 }
 
 static int i2c_vino_client_unreg(struct i2c_client *client)
 {
-        int res = 0;
+        int ret = 0;
 
-        down(&Vino->input_lock);
-        if (client == Vino->decoder.driver) {
-                if (Vino->decoder.owner)
-                        res = -EBUSY;
+        spin_lock(&vino_drvdata->input_lock);
+        if (client == vino_drvdata->decoder.driver) {
+                if (vino_drvdata->decoder.owner != VINO_NO_CHANNEL)
+                        ret = -EBUSY;
                 else
-                        Vino->decoder.driver = NULL;
-        } else if (client == Vino->camera.driver) {
-                if (Vino->camera.owner)
-                        res = -EBUSY;
+                        vino_drvdata->decoder.driver = NULL;
+        } else if (client == vino_drvdata->camera.driver) {
+                if (vino_drvdata->camera.owner != VINO_NO_CHANNEL)
+                        ret = -EBUSY;
                 else
-                        Vino->camera.driver = NULL;
+                        vino_drvdata->camera.driver = NULL;
         }
-        up(&Vino->input_lock);
+        spin_unlock(&vino_drvdata->input_lock);
 
-        return res;
+        return ret;
 }
 
 static struct i2c_adapter vino_i2c_adapter =
@@ -176,172 +702,3591 @@ static int vino_i2c_del_bus(void)
         return i2c_sgi_del_bus(&vino_i2c_adapter);
 }
 
+static int i2c_camera_command(unsigned int cmd, void *arg)
+{
+        return vino_drvdata->camera.driver->
+                driver->command(vino_drvdata->camera.driver,
+                                cmd, arg);
+}
+
+static int i2c_decoder_command(unsigned int cmd, void *arg)
+{
+        return vino_drvdata->decoder.driver->
+                driver->command(vino_drvdata->decoder.driver,
+                                cmd, arg);
+}
+
+/* VINO framebuffer/DMA descriptor management */
+
+static void vino_free_buffer_with_count(struct vino_framebuffer *fb,
+                                               unsigned int count)
+{
+        unsigned int i;
+
+        dprintk("vino_free_buffer_with_count(): count = %d\n", count);
+
+        for (i = 0; i < count; i++) {
+                mem_map_unreserve(virt_to_page(fb->desc_table.virtual[i]));
+                dma_unmap_single(NULL,
+                                 fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
+                                 PAGE_SIZE, DMA_FROM_DEVICE);
+                free_page(fb->desc_table.virtual[i]);
+        }
+
+        dma_free_coherent(NULL,
+                          VINO_PAGE_RATIO * (fb->desc_table.page_count + 4) *
+                          sizeof(dma_addr_t), (void *)fb->desc_table.dma_cpu,
+                          fb->desc_table.dma);
+        kfree(fb->desc_table.virtual);
+
+        memset(fb, 0, sizeof(struct vino_framebuffer));
+}
+
+static void vino_free_buffer(struct vino_framebuffer *fb)
+{
+        vino_free_buffer_with_count(fb, fb->desc_table.page_count);
+}
+
+static int vino_allocate_buffer(struct vino_framebuffer *fb,
+                                unsigned int size)
+{
+        unsigned int count, i, j;
+        int ret = 0;
+
+        dprintk("vino_allocate_buffer():\n");
+
+        if (size < 1)
+                return -EINVAL;
+
+        memset(fb, 0, sizeof(struct vino_framebuffer));
+
+        count = ((size / PAGE_SIZE) + 4) & ~3;
+
+        dprintk("vino_allocate_buffer(): size = %d, count = %d\n",
+                size, count);
+
+        /* allocate memory for table with virtual (page) addresses */
+        fb->desc_table.virtual = (unsigned long *)
+                kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
+        if (!fb->desc_table.virtual)
+                return -ENOMEM;
+
+        /* allocate memory for table with dma addresses
+         * (has space for four extra descriptors) */
+        fb->desc_table.dma_cpu =
+                dma_alloc_coherent(NULL, VINO_PAGE_RATIO * (count + 4) *
+                                   sizeof(dma_addr_t), &fb->desc_table.dma,
+                                   GFP_KERNEL | GFP_DMA);
+        if (!fb->desc_table.dma_cpu) {
+                ret = -ENOMEM;
+                goto out_free_virtual;
+        }
+
+        /* allocate pages for the buffer and acquire the according
+         * dma addresses */
+        for (i = 0; i < count; i++) {
+                dma_addr_t dma_data_addr;
+
+                fb->desc_table.virtual[i] =
+                        get_zeroed_page(GFP_KERNEL | GFP_DMA);
+                if (!fb->desc_table.virtual[i]) {
+                        ret = -ENOBUFS;
+                        break;
+                }
+
+                dma_data_addr =
+                        dma_map_single(NULL,
+                                       (void *)fb->desc_table.virtual[i],
+                                       PAGE_SIZE, DMA_FROM_DEVICE);
+
+                for (j = 0; j < VINO_PAGE_RATIO; j++) {
+                        fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i + j] =
+                                dma_data_addr + VINO_PAGE_SIZE * j;
+                }
+
+                mem_map_reserve(virt_to_page(fb->desc_table.virtual[i]));
+        }
+
+        /* page_count needs to be set anyway, because the descriptor table has
+         * been allocated according to this number */
+        fb->desc_table.page_count = count;
+
+        if (ret) {
+                /* the descriptor with index i doesn't contain
+                 * a valid address yet */
+                vino_free_buffer_with_count(fb, i);
+                return ret;
+        }
+
+        //fb->size = size;
+        fb->size = count * PAGE_SIZE;
+        fb->data_format = VINO_DATA_FMT_NONE;
+
+        /* set the dma stop-bit for the last (count+1)th descriptor */
+        fb->desc_table.dma_cpu[VINO_PAGE_RATIO * count] = VINO_DESC_STOP;
+        return 0;
+
+ out_free_virtual:
+        kfree(fb->desc_table.virtual);
+        return ret;
+}
+
+#if 0
+/* user buffers not fully implemented yet */
+static int vino_prepare_user_buffer(struct vino_framebuffer *fb,
+                                     void *user,
+                                     unsigned int size)
+{
+        unsigned int count, i, j;
+        int ret = 0;
+
+        dprintk("vino_prepare_user_buffer():\n");
+
+        if (size < 1)
+                return -EINVAL;
+
+        memset(fb, 0, sizeof(struct vino_framebuffer));
+
+        count = ((size / PAGE_SIZE)) & ~3;
+
+        dprintk("vino_prepare_user_buffer(): size = %d, count = %d\n",
+                size, count);
+
+        /* allocate memory for table with virtual (page) addresses */
+        fb->desc_table.virtual = (unsigned long *)
+                kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
+        if (!fb->desc_table.virtual)
+                return -ENOMEM;
+
+        /* allocate memory for table with dma addresses
+         * (has space for four extra descriptors) */
+        fb->desc_table.dma_cpu =
+                dma_alloc_coherent(NULL, VINO_PAGE_RATIO * (count + 4) *
+                                   sizeof(dma_addr_t), &fb->desc_table.dma,
+                                   GFP_KERNEL | GFP_DMA);
+        if (!fb->desc_table.dma_cpu) {
+                ret = -ENOMEM;
+                goto out_free_virtual;
+        }
+
+        /* allocate pages for the buffer and acquire the according
+         * dma addresses */
+        for (i = 0; i < count; i++) {
+                dma_addr_t dma_data_addr;
+
+                fb->desc_table.virtual[i] =
+                        get_zeroed_page(GFP_KERNEL | GFP_DMA);
+                if (!fb->desc_table.virtual[i]) {
+                        ret = -ENOBUFS;
+                        break;
+                }
+
+                dma_data_addr =
+                        dma_map_single(NULL,
+                                       (void *)fb->desc_table.virtual[i],
+                                       PAGE_SIZE, DMA_FROM_DEVICE);
+
+                for (j = 0; j < VINO_PAGE_RATIO; j++) {
+                        fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i + j] =
+                                dma_data_addr + VINO_PAGE_SIZE * j;
+                }
+
+                mem_map_reserve(virt_to_page(fb->desc_table.virtual[i]));
+        }
+
+        /* page_count needs to be set anyway, because the descriptor table has
+         * been allocated according to this number */
+        fb->desc_table.page_count = count;
+
+        if (ret) {
+                /* the descriptor with index i doesn't contain
+                 * a valid address yet */
+                vino_free_buffer_with_count(fb, i);
+                return ret;
+        }
+
+        //fb->size = size;
+        fb->size = count * PAGE_SIZE;
+
+        /* set the dma stop-bit for the last (count+1)th descriptor */
+        fb->desc_table.dma_cpu[VINO_PAGE_RATIO * count] = VINO_DESC_STOP;
+        return 0;
+
+ out_free_virtual:
+        kfree(fb->desc_table.virtual);
+        return ret;
+}
+#endif
+
+static void vino_sync_buffer(struct vino_framebuffer *fb)
+{
+        int i;
+
+        dprintk("vino_sync_buffer():\n");
+
+        for (i = 0; i < fb->desc_table.page_count; i++)
+                dma_sync_single(NULL,
+                                fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
+                                PAGE_SIZE, DMA_FROM_DEVICE);
+}
+
+/* Framebuffer fifo functions (need to be locked externally) */
+
+static void vino_fifo_init(struct vino_framebuffer_fifo *f,
+                           unsigned int length)
+{
+        f->length = 0;
+        f->used = 0;
+        f->head = 0;
+        f->tail = 0;
+
+        if (length > VINO_FRAMEBUFFER_MAX_COUNT)
+                length = VINO_FRAMEBUFFER_MAX_COUNT;
+
+        f->length = length;
+}
+
+/* returns true/false */
+static int vino_fifo_has_id(struct vino_framebuffer_fifo *f, unsigned int id)
+{
+        unsigned int i;
+        for (i = f->head; i == (f->tail - 1); i = (i + 1) % f->length) {
+                if (f->data[i] == id)
+                        return 1;
+        }
+
+        return 0;
+}
+
+/* returns true/false */
+static int vino_fifo_full(struct vino_framebuffer_fifo *f)
+{
+        return (f->used == f->length);
+}
+
+static unsigned int vino_fifo_get_used(struct vino_framebuffer_fifo *f)
+{
+        return f->used;
+}
 
-static void vino_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static int vino_fifo_enqueue(struct vino_framebuffer_fifo *f, unsigned int id)
 {
+        if (id >= f->length) {
+                return VINO_QUEUE_ERROR;
+        }
+
+        if (vino_fifo_has_id(f, id)) {
+                return VINO_QUEUE_ERROR;
+        }
+
+        if (f->used < f->length) {
+                f->data[f->tail] = id;
+                f->tail = (f->tail + 1) % f->length;
+                f->used++;
+        } else {
+                return VINO_QUEUE_ERROR;
+        }
+
+        return 0;
 }
 
-static int vino_open(struct video_device *dev, int flags)
+static int vino_fifo_peek(struct vino_framebuffer_fifo *f, unsigned int *id)
 {
-        struct vino_device *videv = (struct vino_device *)dev;
+        if (f->used > 0) {
+                *id = f->data[f->head];
+        } else {
+                return VINO_QUEUE_ERROR;
+        }
 
         return 0;
 }
 
-static void vino_close(struct video_device *dev)
+static int vino_fifo_dequeue(struct vino_framebuffer_fifo *f, unsigned int *id)
 {
-        struct vino_device *videv = (struct vino_device *)dev;
+        if (f->used > 0) {
+                *id = f->data[f->head];
+                f->head = (f->head + 1) % f->length;
+                f->used--;
+        } else {
+                return VINO_QUEUE_ERROR;
+        }
+
+        return 0;
 }
 
-static int vino_mmap(struct video_device *dev, const char *adr,
-                     unsigned long size)
+/* Framebuffer queue functions */
+
+/* execute with queue_lock locked */
+static void vino_queue_free_with_count(struct vino_framebuffer_queue *q,
+                                       unsigned int length)
 {
-        struct vino_device *videv = (struct vino_device *)dev;
+        unsigned int i;
 
-        return -EINVAL;
+        q->length = 0;
+        memset(&q->in, 0, sizeof(struct vino_framebuffer_fifo));
+        memset(&q->out, 0, sizeof(struct vino_framebuffer_fifo));
+        for (i = 0; i < length; i++) {
+                dprintk("vino_queue_free_with_count(): freeing buffer %d\n",
+                        i);
+                vino_free_buffer(q->buffer[i]);
+                kfree(q->buffer[i]);
+        }
+
+        q->type = VINO_MEMORY_NONE;
+        q->magic = 0;
 }
 
-static int vino_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
+static void vino_queue_free(struct vino_framebuffer_queue *q)
 {
-        struct vino_device *videv = (struct vino_device *)dev;
+        dprintk("vino_queue_free():\n");
+
+        if (q->magic != VINO_QUEUE_MAGIC)
+                return;
+        if (q->type != VINO_MEMORY_MMAP)
+                return;
+
+        down(&q->queue_sem);
+
+        vino_queue_free_with_count(q, q->length);
+
+        up(&q->queue_sem);
+}
+
+static int vino_queue_init(struct vino_framebuffer_queue *q,
+                           unsigned int *length)
+{
+        unsigned int i;
+        int ret = 0;
+
+        dprintk("vino_queue_init(): length = %d\n", *length);
+
+        if (q->magic == VINO_QUEUE_MAGIC) {
+                dprintk("vino_queue_init(): queue already initialized!\n");
+                return -EINVAL;
+        }
+
+        if (q->type != VINO_MEMORY_NONE) {
+                dprintk("vino_queue_init(): queue already initialized!\n");
+                return -EINVAL;
+        }
+
+        if (*length < 1)
+                return -EINVAL;
+
+        down(&q->queue_sem);
+
+        if (*length > VINO_FRAMEBUFFER_MAX_COUNT)
+                *length = VINO_FRAMEBUFFER_MAX_COUNT;
+
+        q->length = 0;
+
+        for (i = 0; i < *length; i++) {
+                dprintk("vino_queue_init(): allocating buffer %d\n", i);
+                q->buffer[i] = kmalloc(sizeof(struct vino_framebuffer),
+                                       GFP_KERNEL);
+                if (!q->buffer[i]) {
+                        dprintk("vino_queue_init(): kmalloc() failed\n");
+                        ret = -ENOMEM;
+                        break;
+                }
+
+                ret = vino_allocate_buffer(q->buffer[i],
+                                           VINO_FRAMEBUFFER_SIZE);
+                if (ret) {
+                        kfree(q->buffer[i]);
+                        dprintk("vino_queue_init(): "
+                                "vino_allocate_buffer() failed\n");
+                        break;
+                }
+
+                q->buffer[i]->id = i;
+                if (i > 0) {
+                        q->buffer[i]->offset = q->buffer[i - 1]->offset +
+                                q->buffer[i - 1]->size;
+                } else {
+                        q->buffer[i]->offset = 0;
+                }
+
+                spin_lock_init(&q->buffer[i]->state_lock);
+
+                dprintk("vino_queue_init(): buffer = %d, offset = %d, "
+                        "size = %d\n", i, q->buffer[i]->offset,
+                        q->buffer[i]->size);
+        }
+
+        if (ret) {
+                vino_queue_free_with_count(q, i);
+                *length = 0;
+        } else {
+                q->length = *length;
+                vino_fifo_init(&q->in, q->length);
+                vino_fifo_init(&q->out, q->length);
+                q->type = VINO_MEMORY_MMAP;
+                q->magic = VINO_QUEUE_MAGIC;
+        }
+
+        up(&q->queue_sem);
+
+        return ret;
+}
+
+static struct vino_framebuffer *vino_queue_add(struct
+                                               vino_framebuffer_queue *q,
+                                               unsigned int id)
+{
+        struct vino_framebuffer *ret = NULL;
+        unsigned int total;
+        unsigned long flags;
+
+        dprintk("vino_queue_add(): id = %d\n", id);
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        if (id >= q->length)
+                goto out;
+
+        /* not needed?: if (vino_fifo_full(&q->out)) {
+                goto out;
+                }*/
+        /* check that outgoing queue isn't already full
+         * (or that it won't become full) */
+        total = vino_fifo_get_used(&q->in) +
+                vino_fifo_get_used(&q->out);
+        if (total >= q->length)
+                goto out;
+
+        if (vino_fifo_enqueue(&q->in, id))
+                goto out;
+
+        ret = q->buffer[id];
+
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static struct vino_framebuffer *vino_queue_transfer(struct
+                                                    vino_framebuffer_queue *q)
+{
+        struct vino_framebuffer *ret = NULL;
+        struct vino_framebuffer *fb;
+        int id;
+        unsigned long flags;
+
+        dprintk("vino_queue_transfer():\n");
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        // now this actually removes an entry from the incoming queue
+        if (vino_fifo_dequeue(&q->in, &id)) {
+                goto out;
+        }
+
+        dprintk("vino_queue_transfer(): id = %d\n", id);
+        fb = q->buffer[id];
+
+        // we have already checked that the outgoing queue is not full, but...
+        if (vino_fifo_enqueue(&q->out, id)) {
+                printk(KERN_ERR "vino_queue_transfer(): "
+                       "outgoing queue is full, this shouldn't happen!\n");
+                goto out;
+        }
+
+        ret = fb;
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+/* returns true/false */
+static int vino_queue_incoming_contains(struct vino_framebuffer_queue *q,
+                                        unsigned int id)
+{
+        int ret = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        ret = vino_fifo_has_id(&q->in, id);
+
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+/* returns true/false */
+static int vino_queue_outgoing_contains(struct vino_framebuffer_queue *q,
+                                        unsigned int id)
+{
+        int ret = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        ret = vino_fifo_has_id(&q->out, id);
+
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static int vino_queue_get_incoming(struct vino_framebuffer_queue *q,
+                                   unsigned int *used)
+{
+        int ret = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return VINO_QUEUE_ERROR;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0) {
+                ret = VINO_QUEUE_ERROR;
+                goto out;
+        }
+
+        *used = vino_fifo_get_used(&q->in);
+
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static int vino_queue_get_outgoing(struct vino_framebuffer_queue *q,
+                                   unsigned int *used)
+{
+        int ret = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return VINO_QUEUE_ERROR;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0) {
+                ret = VINO_QUEUE_ERROR;
+                goto out;
+        }
+
+        *used = vino_fifo_get_used(&q->out);
+
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static int vino_queue_get_total(struct vino_framebuffer_queue *q,
+                                unsigned int *total)
+{
+        int ret = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return VINO_QUEUE_ERROR;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0) {
+                ret = VINO_QUEUE_ERROR;
+                goto out;
+        }
+
+        *total = vino_fifo_get_used(&q->in) +
+                vino_fifo_get_used(&q->out);
+
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static struct vino_framebuffer *vino_queue_peek(struct
+                                                vino_framebuffer_queue *q,
+                                                unsigned int *id)
+{
+        struct vino_framebuffer *ret = NULL;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        if (vino_fifo_peek(&q->in, id)) {
+                goto out;
+        }
+
+        ret = q->buffer[*id];
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static struct vino_framebuffer *vino_queue_remove(struct
+                                                  vino_framebuffer_queue *q,
+                                                  unsigned int *id)
+{
+        struct vino_framebuffer *ret = NULL;
+        unsigned long flags;
+        dprintk("vino_queue_remove():\n");
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        if (vino_fifo_dequeue(&q->out, id)) {
+                goto out;
+        }
+
+        dprintk("vino_queue_remove(): id = %d\n", *id);
+        ret = q->buffer[*id];
+out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static struct
+vino_framebuffer *vino_queue_get_buffer(struct vino_framebuffer_queue *q,
+                                        unsigned int id)
+{
+        struct vino_framebuffer *ret = NULL;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+
+        if (q->length == 0)
+                goto out;
+
+        if (id >= q->length)
+                goto out;
+
+        ret = q->buffer[id];
+ out:
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+static unsigned int vino_queue_get_length(struct vino_framebuffer_queue *q)
+{
+        unsigned int length = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return length;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+        length = q->length;
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return length;
+}
+
+static int vino_queue_has_mapped_buffers(struct vino_framebuffer_queue *q)
+{
+        unsigned int i;
+        int ret = 0;
+        unsigned long flags;
+
+        if (q->magic != VINO_QUEUE_MAGIC) {
+                return ret;
+        }
+
+        spin_lock_irqsave(&q->queue_lock, flags);
+        for (i = 0; i < q->length; i++) {
+                if (q->buffer[i]->map_count > 0) {
+                        ret = 1;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&q->queue_lock, flags);
+
+        return ret;
+}
+
+/* VINO functions */
+
+/* execute with input_lock locked */
+static void vino_update_line_size(struct vino_channel_settings *vcs)
+{
+        unsigned int w = vcs->clipping.right - vcs->clipping.left;
+        unsigned int d = vcs->decimation;
+        unsigned int bpp = vino_data_formats[vcs->data_format].bpp;
+        unsigned int lsize;
+
+        dprintk("update_line_size(): before: w = %d, d = %d, "
+                "line_size = %d\n", w, d, vcs->line_size);
+        /* line size must be multiple of 8 bytes */
+        lsize = (bpp * (w / d)) & ~7;
+        w = (lsize / bpp) * d;
+
+        vcs->clipping.right = vcs->clipping.left + w;
+        vcs->line_size = lsize;
+        dprintk("update_line_size(): after: w = %d, d = %d, "
+                "line_size = %d\n", w, d, vcs->line_size);
+}
+
+/* execute with input_lock locked */
+static void vino_set_clipping(struct vino_channel_settings *vcs,
+                              unsigned int x, unsigned int y,
+                              unsigned int w, unsigned int h)
+{
+        unsigned int maxwidth, maxheight;
+        unsigned int d;
+
+        maxwidth = vino_data_norms[vcs->data_norm].width;
+        maxheight = vino_data_norms[vcs->data_norm].height;
+        d = vcs->decimation;
+
+        y &= ~1;        /* odd/even fields */
+
+        if (x > maxwidth) {
+                x = 0;
+        }
+        if (y > maxheight) {
+                y = 0;
+        }
+
+        if (((w / d) < VINO_MIN_WIDTH)
+            || ((h / d) < VINO_MIN_HEIGHT)) {
+                w = VINO_MIN_WIDTH * d;
+                h = VINO_MIN_HEIGHT * d;
+        }
+
+        if ((x + w) > maxwidth) {
+                w = maxwidth - x;
+                if ((w / d) < VINO_MIN_WIDTH)
+                        x = maxwidth - VINO_MIN_WIDTH * d;
+        }
+        if ((y + h) > maxheight) {
+                h = maxheight - y;
+                if ((h / d) < VINO_MIN_HEIGHT)
+                        y = maxheight - VINO_MIN_HEIGHT * d;
+        }
+
+        vcs->clipping.left = x;
+        vcs->clipping.top = y;
+        vcs->clipping.right = x + w;
+        vcs->clipping.bottom = y + h;
+
+        vino_update_line_size(vcs);
+
+        dprintk("clipping %d, %d, %d, %d / %d - %d\n",
+                vcs->clipping.left, vcs->clipping.top, vcs->clipping.right,
+                vcs->clipping.bottom, vcs->decimation, vcs->line_size);
+}
+
+/* execute with input_lock locked */
+static void vino_set_default_clipping(struct vino_channel_settings *vcs)
+{
+        vino_set_clipping(vcs, 0, 0, vino_data_norms[vcs->data_norm].width,
+                          vino_data_norms[vcs->data_norm].height);
+}
+
+/* execute with input_lock locked */
+static void vino_set_scaling(struct vino_channel_settings *vcs,
+                             unsigned int w, unsigned int h)
+{
+        unsigned int x, y, curw, curh, d;
+
+        x = vcs->clipping.left;
+        y = vcs->clipping.top;
+        curw = vcs->clipping.right - vcs->clipping.left;
+        curh = vcs->clipping.bottom - vcs->clipping.top;
+
+        d = max(curw / w, curh / h);
+
+        dprintk("scaling w: %d, h: %d, curw: %d, curh: %d, d: %d\n",
+                w, h, curw, curh, d);
+
+        if (d < 1) {
+                d = 1;
+        }
+        if (d > 8) {
+                d = 8;
+        }
+
+        vcs->decimation = d;
+        vino_set_clipping(vcs, x, y, w * d, h * d);
+
+        dprintk("scaling %d, %d, %d, %d / %d - %d\n", vcs->clipping.left,
+                vcs->clipping.top, vcs->clipping.right, vcs->clipping.bottom,
+                vcs->decimation, vcs->line_size);
+}
+
+/* execute with input_lock locked */
+static void vino_reset_scaling(struct vino_channel_settings *vcs)
+{
+        vino_set_scaling(vcs, vcs->clipping.right - vcs->clipping.left,
+                         vcs->clipping.bottom - vcs->clipping.top);
+}
+
+/* execute with input_lock locked */
+static void vino_set_framerate(struct vino_channel_settings *vcs,
+                               unsigned int fps)
+{
+        unsigned int mask;
+
+        switch (vcs->data_norm) {
+        case VINO_DATA_NORM_NTSC:
+        case VINO_DATA_NORM_D1:
+                fps = (unsigned int)(fps / 6) * 6; // FIXME: round!
+
+                if (fps < vino_data_norms[vcs->data_norm].fps_min)
+                        fps = vino_data_norms[vcs->data_norm].fps_min;
+                if (fps > vino_data_norms[vcs->data_norm].fps_max)
+                        fps = vino_data_norms[vcs->data_norm].fps_max;
+
+                switch (fps) {
+                case 6:
+                        mask = 0x003;
+                        break;
+                case 12:
+                        mask = 0x0c3;
+                        break;
+                case 18:
+                        mask = 0x333;
+                        break;
+                case 24:
+                        mask = 0x3ff;
+                        break;
+                case 30:
+                        mask = 0xfff;
+                        break;
+                default:
+                        mask = VINO_FRAMERT_FULL;
+                }
+                vcs->framert_reg = VINO_FRAMERT_RT(mask);
+                break;
+        case VINO_DATA_NORM_PAL:
+        case VINO_DATA_NORM_SECAM:
+                fps = (unsigned int)(fps / 5) * 5; // FIXME: round!
+
+                if (fps < vino_data_norms[vcs->data_norm].fps_min)
+                        fps = vino_data_norms[vcs->data_norm].fps_min;
+                if (fps > vino_data_norms[vcs->data_norm].fps_max)
+                        fps = vino_data_norms[vcs->data_norm].fps_max;
+
+                switch (fps) {
+                case 5:
+                        mask = 0x003;
+                        break;
+                case 10:
+                        mask = 0x0c3;
+                        break;
+                case 15:
+                        mask = 0x333;
+                        break;
+                case 20:
+                        mask = 0x0ff;
+                        break;
+                case 25:
+                        mask = 0x3ff;
+                        break;
+                default:
+                        mask = VINO_FRAMERT_FULL;
+                }
+                vcs->framert_reg = VINO_FRAMERT_RT(mask) | VINO_FRAMERT_PAL;
+                break;
+        }
+
+        vcs->fps = fps;
+}
+
+/* execute with input_lock locked */
+static void vino_set_default_framerate(struct vino_channel_settings *vcs)
+{
+        vino_set_framerate(vcs, vino_data_norms[vcs->data_norm].fps_max);
+}
+
+/*
+ * Prepare VINO for DMA transfer...
+ * (execute only with vino_lock and input_lock locked)
+ */
+static int vino_dma_setup(struct vino_channel_settings *vcs,
+                          struct vino_framebuffer *fb)
+{
+        u32 ctrl, intr;
+        struct sgi_vino_channel *ch;
+        const struct vino_data_norm *norm;
+
+        dprintk("vino_dma_setup():\n");
+
+        vcs->field = 0;
+        fb->frame_counter = 0;
+
+        ch = (vcs->channel == VINO_CHANNEL_A) ? &vino->a : &vino->b;
+        norm = &vino_data_norms[vcs->data_norm];
+
+        ch->page_index = 0;
+        ch->line_count = 0;
+
+        /* VINO line size register is set 8 bytes less than actual */
+        ch->line_size = vcs->line_size - 8;
+
+        /* let VINO know where to transfer data */
+        ch->start_desc_tbl = fb->desc_table.dma;
+        ch->next_4_desc = fb->desc_table.dma;
+
+        /* give vino time to fetch the first four descriptors, 5 usec
+         * should be more than enough time */
+        udelay(VINO_DESC_FETCH_DELAY);
+
+        /* set the alpha register */
+        ch->alpha = vcs->alpha;
+
+        /* set clipping registers */
+        ch->clip_start = VINO_CLIP_ODD(norm->odd.top + vcs->clipping.top / 2) |
+                VINO_CLIP_EVEN(norm->even.top +
+                               vcs->clipping.top / 2) |
+                VINO_CLIP_X(vcs->clipping.left);
+        ch->clip_end = VINO_CLIP_ODD(norm->odd.top +
+                                     vcs->clipping.bottom / 2 - 1) |
+                VINO_CLIP_EVEN(norm->even.top +
+                               vcs->clipping.bottom / 2 - 1) |
+                VINO_CLIP_X(vcs->clipping.right);
+        /* FIXME: end-of-field bug workaround
+                       VINO_CLIP_X(VINO_PAL_WIDTH);
+         */
+
+        /* set the size of actual content in the buffer (DECIMATION !) */
+        fb->data_size = ((vcs->clipping.right - vcs->clipping.left) /
+                         vcs->decimation) *
+                ((vcs->clipping.bottom - vcs->clipping.top) /
+                 vcs->decimation) *
+                vino_data_formats[vcs->data_format].bpp;
+
+        ch->frame_rate = vcs->framert_reg;
+
+        ctrl = vino->control;
+        intr = vino->intr_status;
+
+        if (vcs->channel == VINO_CHANNEL_A) {
+                /* All interrupt conditions for this channel was cleared
+                 * so clear the interrupt status register and enable
+                 * interrupts */
+                intr &= ~VINO_INTSTAT_A;
+                ctrl |= VINO_CTRL_A_INT;
+
+                /* enable synchronization */
+                ctrl |= VINO_CTRL_A_SYNC_ENBL;
+
+                /* enable frame assembly */
+                ctrl |= VINO_CTRL_A_INTERLEAVE_ENBL;
+
+                /* set decimation used */
+                if (vcs->decimation < 2)
+                        ctrl &= ~VINO_CTRL_A_DEC_ENBL;
+                else {
+                        ctrl |= VINO_CTRL_A_DEC_ENBL;
+                        ctrl &= ~VINO_CTRL_A_DEC_SCALE_MASK;
+                        ctrl |= (vcs->decimation - 1) <<
+                                VINO_CTRL_A_DEC_SCALE_SHIFT;
+                }
+
+                /* select input interface */
+                if (vcs->input == VINO_INPUT_D1)
+                        ctrl |= VINO_CTRL_A_SELECT;
+                else
+                        ctrl &= ~VINO_CTRL_A_SELECT;
+
+                /* palette */
+                ctrl &= ~(VINO_CTRL_A_LUMA_ONLY | VINO_CTRL_A_RGB |
+                          VINO_CTRL_A_DITHER);
+        } else {
+                intr &= ~VINO_INTSTAT_B;
+                ctrl |= VINO_CTRL_B_INT;
+
+                ctrl |= VINO_CTRL_B_SYNC_ENBL;
+                ctrl |= VINO_CTRL_B_INTERLEAVE_ENBL;
+
+                if (vcs->decimation < 2)
+                        ctrl &= ~VINO_CTRL_B_DEC_ENBL;
+                else {
+                        ctrl |= VINO_CTRL_B_DEC_ENBL;
+                        ctrl &= ~VINO_CTRL_B_DEC_SCALE_MASK;
+                        ctrl |= (vcs->decimation - 1) <<
+                                VINO_CTRL_B_DEC_SCALE_SHIFT;
+
+                }
+                if (vcs->input == VINO_INPUT_D1)
+                        ctrl |= VINO_CTRL_B_SELECT;
+                else
+                        ctrl &= ~VINO_CTRL_B_SELECT;
+
+                ctrl &= ~(VINO_CTRL_B_LUMA_ONLY | VINO_CTRL_B_RGB |
+                          VINO_CTRL_B_DITHER);
+        }
+
+        /* set palette */
+        fb->data_format = vcs->data_format;
+
+        switch (vcs->data_format) {
+                case VINO_DATA_FMT_GREY:
+                        ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
+                                VINO_CTRL_A_LUMA_ONLY : VINO_CTRL_B_LUMA_ONLY;
+                        break;
+                case VINO_DATA_FMT_RGB32:
+                        ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
+                                VINO_CTRL_A_RGB : VINO_CTRL_B_RGB;
+                        break;
+                case VINO_DATA_FMT_YUV:
+                        /* nothing needs to be done */
+                        break;
+                case VINO_DATA_FMT_RGB332:
+                        ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
+                                VINO_CTRL_A_RGB | VINO_CTRL_A_DITHER :
+                                VINO_CTRL_B_RGB | VINO_CTRL_B_DITHER;
+                        break;
+        }
+
+        vino->intr_status = intr;
+        vino->control = ctrl;
+
+        return 0;
+}
+
+/* (execute only with vino_lock locked) */
+static void vino_dma_start(struct vino_channel_settings *vcs)
+{
+        u32 ctrl = vino->control;
+
+        dprintk("vino_dma_start():\n");
+        ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
+                VINO_CTRL_A_DMA_ENBL : VINO_CTRL_B_DMA_ENBL;
+        vino->control = ctrl;
+}
+
+/* (execute only with vino_lock locked) */
+static void vino_dma_stop(struct vino_channel_settings *vcs)
+{
+        u32 ctrl = vino->control;
+
+        ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
+                ~VINO_CTRL_A_DMA_ENBL : ~VINO_CTRL_B_DMA_ENBL;
+        vino->control = ctrl;
+        dprintk("vino_dma_stop():\n");
+}
+
+/*
+ * Load dummy page to descriptor registers. This prevents generating of
+ * spurious interrupts. (execute only with vino_lock locked)
+ */
+static void vino_clear_interrupt(struct vino_channel_settings *vcs)
+{
+        struct sgi_vino_channel *ch;
+
+        ch = (vcs->channel == VINO_CHANNEL_A) ? &vino->a : &vino->b;
+
+        ch->page_index = 0;
+        ch->line_count = 0;
+
+        ch->start_desc_tbl = vino_drvdata->dummy_desc_table.dma;
+        ch->next_4_desc = vino_drvdata->dummy_desc_table.dma;
+
+        udelay(VINO_DESC_FETCH_DELAY);
+        dprintk("channel %c clear interrupt condition\n",
+               (vcs->channel == VINO_CHANNEL_A) ? 'A':'B');
+}
+
+static int vino_capture(struct vino_channel_settings *vcs,
+                        struct vino_framebuffer *fb)
+{
+        int err = 0;
+        unsigned long flags, flags2;
+
+        spin_lock_irqsave(&fb->state_lock, flags);
+
+        if (fb->state == VINO_FRAMEBUFFER_IN_USE)
+                err = -EBUSY;
+        fb->state = VINO_FRAMEBUFFER_IN_USE;
+
+        spin_unlock_irqrestore(&fb->state_lock, flags);
+
+        if (err)
+                return err;
+
+        spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
+        spin_lock_irqsave(&vino_drvdata->input_lock, flags2);
+
+        vino_dma_setup(vcs, fb);
+        vino_dma_start(vcs);
+
+        spin_unlock_irqrestore(&vino_drvdata->input_lock, flags2);
+        spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
+
+        return err;
+}
+
+static
+struct vino_framebuffer *vino_capture_enqueue(struct
+                                              vino_channel_settings *vcs,
+                                              unsigned int index)
+{
+        struct vino_framebuffer *fb;
+        unsigned long flags;
+
+        dprintk("vino_capture_enqueue():\n");
+
+        spin_lock_irqsave(&vcs->capture_lock, flags);
+
+        fb = vino_queue_add(&vcs->fb_queue, index);
+        if (fb == NULL) {
+                dprintk("vino_capture_enqueue(): vino_queue_add() failed, "
+                        "queue full?\n");
+                goto out;
+        }
+out:
+        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+
+        return fb;
+}
+
+static int vino_capture_next(struct vino_channel_settings *vcs, int start)
+{
+        struct vino_framebuffer *fb;
+        unsigned int incoming, id;
+        int err = 0;
+        unsigned long flags, flags2;
+
+        dprintk("vino_capture_next():\n");
+
+        spin_lock_irqsave(&vcs->capture_lock, flags);
+
+        if (start) {
+                /* start capture only if capture isn't in progress already */
+                if (vcs->capturing) {
+                        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+                        return 0;
+                }
+
+        } else {
+                /* capture next frame:
+                 * stop capture if capturing is not set */
+                if (!vcs->capturing) {
+                        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+                        return 0;
+                }
+        }
+
+        err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
+        if (err) {
+                dprintk("vino_capture_next(): vino_queue_get_incoming() "
+                        "failed\n");
+                err = -EINVAL;
+                goto out;
+        }
+        if (incoming == 0) {
+                dprintk("vino_capture_next(): no buffers available\n");
+                goto out;
+        }
+
+        fb = vino_queue_peek(&vcs->fb_queue, &id);
+        if (fb == NULL) {
+                dprintk("vino_capture_next(): vino_queue_peek() failed\n");
+                err = -EINVAL;
+                goto out;
+        }
+
+        spin_lock_irqsave(&fb->state_lock, flags2);
+        fb->state = VINO_FRAMEBUFFER_UNUSED;
+        spin_unlock_irqrestore(&fb->state_lock, flags2);
+
+        if (start) {
+                vcs->capturing = 1;
+        }
+
+        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+
+        err = vino_capture(vcs, fb);
+
+        return err;
+
+out:
+        vcs->capturing = 0;
+        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+
+        return err;
+}
+
+static int vino_is_capturing(struct vino_channel_settings *vcs)
+{
+        int ret;
+        unsigned long flags;
+
+        spin_lock_irqsave(&vcs->capture_lock, flags);
+
+        ret = vcs->capturing;
+
+        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+
+        return ret;
+}
+
+/* waits until a frame is captured */
+static int vino_wait_for_frame(struct vino_channel_settings *vcs)
+{
+        wait_queue_t wait;
+        int err = 0;
+
+        dprintk("vino_wait_for_frame():\n");
+
+        init_waitqueue_entry(&wait, current);
+        /* add ourselves into wait queue */
+        add_wait_queue(&vcs->fb_queue.frame_wait_queue, &wait);
+        /* and set current state */
+        set_current_state(TASK_INTERRUPTIBLE);
+
+        /* to ensure that schedule_timeout will return immediately
+         * if VINO interrupt was triggred meanwhile */
+        schedule_timeout(HZ / 10);
+
+        if (signal_pending(current))
+                err = -EINTR;
+
+        remove_wait_queue(&vcs->fb_queue.frame_wait_queue, &wait);
+
+        dprintk("vino_wait_for_frame(): waiting for frame %s\n",
+                err ? "failed" : "ok");
+
+        return err;
+}
+
+/* the function assumes that PAGE_SIZE % 4 == 0 */
+static void vino_convert_to_rgba(struct vino_framebuffer *fb) {
+        unsigned char *pageptr;
+        unsigned int page, i;
+        unsigned char a;
+
+        for (page = 0; page < fb->desc_table.page_count; page++) {
+                pageptr = (unsigned char *)fb->desc_table.virtual[page];
+
+                for (i = 0; i < PAGE_SIZE; i += 4) {
+                        a = pageptr[0];
+                        pageptr[0] = pageptr[3];
+                        pageptr[1] = pageptr[2];
+                        pageptr[2] = pageptr[1];
+                        pageptr[3] = a;
+                        pageptr += 4;
+                }
+        }
+}
+
+/* checks if the buffer is in correct state and syncs data */
+static int vino_check_buffer(struct vino_channel_settings *vcs,
+                             struct vino_framebuffer *fb)
+{
+        int err = 0;
+        unsigned long flags;
+
+        dprintk("vino_check_buffer():\n");
+
+        spin_lock_irqsave(&fb->state_lock, flags);
+        switch (fb->state) {
+        case VINO_FRAMEBUFFER_IN_USE:
+                err = -EIO;
+                break;
+        case VINO_FRAMEBUFFER_READY:
+                vino_sync_buffer(fb);
+                fb->state = VINO_FRAMEBUFFER_UNUSED;
+                break;
+        default:
+                err = -EINVAL;
+        }
+        spin_unlock_irqrestore(&fb->state_lock, flags);
+
+        if (!err) {
+                if (vino_pixel_conversion
+                    && (fb->data_format == VINO_DATA_FMT_RGB32)) {
+                        vino_convert_to_rgba(fb);
+                }
+        } else if (err && (err != -EINVAL)) {
+                dprintk("vino_check_buffer(): buffer not ready\n");
+
+                spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
+                vino_dma_stop(vcs);
+                vino_clear_interrupt(vcs);
+                spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
+        }
+
+        return err;
+}
+
+/* forcefully terminates capture */
+static void vino_capture_stop(struct vino_channel_settings *vcs)
+{
+        unsigned int incoming = 0, outgoing = 0, id;
+        unsigned long flags, flags2;
+
+        dprintk("vino_capture_stop():\n");
+
+        spin_lock_irqsave(&vcs->capture_lock, flags);
+        /* unset capturing to stop queue processing */
+        vcs->capturing = 0;
+
+        spin_lock_irqsave(&vino_drvdata->vino_lock, flags2);
+
+        vino_dma_stop(vcs);
+        vino_clear_interrupt(vcs);
+
+        spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags2);
+
+        /* remove all items from the queue */
+        if (vino_queue_get_incoming(&vcs->fb_queue, &incoming)) {
+                dprintk("vino_capture_stop(): "
+                        "vino_queue_get_incoming() failed\n");
+                goto out;
+        }
+        while (incoming > 0) {
+                vino_queue_transfer(&vcs->fb_queue);
+
+                if (vino_queue_get_incoming(&vcs->fb_queue, &incoming)) {
+                        dprintk("vino_capture_stop(): "
+                                "vino_queue_get_incoming() failed\n");
+                        goto out;
+                }
+        }
+
+        if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
+                dprintk("vino_capture_stop(): "
+                        "vino_queue_get_outgoing() failed\n");
+                goto out;
+        }
+        while (outgoing > 0) {
+                vino_queue_remove(&vcs->fb_queue, &id);
+
+                if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
+                        dprintk("vino_capture_stop(): "
+                                "vino_queue_get_outgoing() failed\n");
+                        goto out;
+                }
+        }
+
+out:
+        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+}
+
+static int vino_capture_failed(struct vino_channel_settings *vcs)
+{
+        struct vino_framebuffer *fb;
+        unsigned long flags;
+        unsigned int i;
+        int ret;
+
+        dprintk("vino_capture_failed():\n");
+
+        spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
+
+        vino_dma_stop(vcs);
+        vino_clear_interrupt(vcs);
+
+        spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
+
+        ret = vino_queue_get_incoming(&vcs->fb_queue, &i);
+        if (ret == VINO_QUEUE_ERROR) {
+                dprintk("vino_queue_get_incoming() failed\n");
+                return -EINVAL;
+        }
+        if (i == 0) {
+                /* no buffers to process */
+                return 0;
+        }
+
+        fb = vino_queue_peek(&vcs->fb_queue, &i);
+        if (fb == NULL) {
+                dprintk("vino_queue_peek() failed\n");
+                return -EINVAL;
+        }
+
+        spin_lock_irqsave(&fb->state_lock, flags);
+        if (fb->state == VINO_FRAMEBUFFER_IN_USE) {
+                fb->state = VINO_FRAMEBUFFER_UNUSED;
+                vino_queue_transfer(&vcs->fb_queue);
+                vino_queue_remove(&vcs->fb_queue, &i);
+                /* we should actually discard the newest frame,
+                 * but who cares ... */
+        }
+        spin_unlock_irqrestore(&fb->state_lock, flags);
+
+        return 0;
+}
+
+static void vino_frame_done(struct vino_channel_settings *vcs,
+                            unsigned int fc)
+{
+        struct vino_framebuffer *fb;
+        unsigned long flags;
+
+        spin_lock_irqsave(&vcs->capture_lock, flags);
+        fb = vino_queue_transfer(&vcs->fb_queue);
+        if (!fb) {
+                spin_unlock_irqrestore(&vcs->capture_lock, flags);
+                dprintk("vino_frame_done(): vino_queue_transfer() failed!\n");
+                return;
+        }
+        spin_unlock_irqrestore(&vcs->capture_lock, flags);
+
+        fb->frame_counter = fc;
+        do_gettimeofday(&fb->timestamp);
+
+        spin_lock_irqsave(&fb->state_lock, flags);
+        if (fb->state == VINO_FRAMEBUFFER_IN_USE)
+                fb->state = VINO_FRAMEBUFFER_READY;
+        spin_unlock_irqrestore(&fb->state_lock, flags);
+
+        wake_up(&vcs->fb_queue.frame_wait_queue);
+
+        vino_capture_next(vcs, 0);
+}
+
+static irqreturn_t vino_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        u32 intr;
+        unsigned int fc_a, fc_b;
+        int done_a = 0;
+        int done_b = 0;
+
+        spin_lock(&vino_drvdata->vino_lock);
+
+        intr = vino->intr_status;
+        fc_a = vino->a.field_counter / 2;
+        fc_b = vino->b.field_counter / 2;
+
+        // TODO: handle error-interrupts in some special way ?
+
+        if (intr & VINO_INTSTAT_A) {
+                if (intr & VINO_INTSTAT_A_EOF) {
+                        vino_drvdata->a.field++;
+                        if (vino_drvdata->a.field > 1) {
+                                vino_dma_stop(&vino_drvdata->a);
+                                vino_clear_interrupt(&vino_drvdata->a);
+                                vino_drvdata->a.field = 0;
+                                done_a = 1;
+                        }
+                        dprintk("intr: channel A end-of-field interrupt: "
+                                "%04x\n", intr);
+                } else {
+                        vino_dma_stop(&vino_drvdata->a);
+                        vino_clear_interrupt(&vino_drvdata->a);
+                        done_a = 1;
+                        dprintk("channel A error interrupt: %04x\n", intr);
+                }
+        }
+        if (intr & VINO_INTSTAT_B) {
+                if (intr & VINO_INTSTAT_B_EOF) {
+                        vino_drvdata->b.field++;
+                        if (vino_drvdata->b.field > 1) {
+                                vino_dma_stop(&vino_drvdata->b);
+                                vino_clear_interrupt(&vino_drvdata->b);
+                                vino_drvdata->b.field = 0;
+                                done_b = 1;
+                        }
+                        dprintk("intr: channel B end-of-field interrupt: "
+                                "%04x\n", intr);
+                } else {
+                        vino_dma_stop(&vino_drvdata->b);
+                        vino_clear_interrupt(&vino_drvdata->b);
+                        done_b = 1;
+                        dprintk("channel B error interrupt: %04x\n", intr);
+                }
+        }
+
+        /* always remember to clear interrupt status */
+        vino->intr_status = ~intr;
+
+        spin_unlock(&vino_drvdata->vino_lock);
+
+        if (done_a) {
+                vino_frame_done(&vino_drvdata->a, fc_a);
+                dprintk("channel A frame done, interrupt: %d\n", intr);
+        }
+        if (done_b) {
+                vino_frame_done(&vino_drvdata->b, fc_b);
+                dprintk("channel B frame done, interrupt: %d\n", intr);
+        }
 
-        return -EINVAL;
+        return IRQ_HANDLED;
 }
 
-static const struct video_device vino_device = {
+/* VINO video input management */
+
+static int vino_get_saa7191_input(int input)
+{
+        switch (input) {
+        case VINO_INPUT_COMPOSITE:
+                return SAA7191_INPUT_COMPOSITE;
+        case VINO_INPUT_SVIDEO:
+                return SAA7191_INPUT_SVIDEO;
+        default:
+                printk(KERN_ERR "VINO: vino_get_saa7191_input(): "
+                       "invalid input!\n");
+                return -1;
+        }
+}
+
+static int vino_get_saa7191_norm(int norm)
+{
+        switch (norm) {
+        case VINO_DATA_NORM_AUTO:
+                return SAA7191_NORM_AUTO;
+        case VINO_DATA_NORM_PAL:
+                return SAA7191_NORM_PAL;
+        case VINO_DATA_NORM_NTSC:
+                return SAA7191_NORM_NTSC;
+        case VINO_DATA_NORM_SECAM:
+                return SAA7191_NORM_SECAM;
+        default:
+                printk(KERN_ERR "VINO: vino_get_saa7191_norm(): "
+                       "invalid norm!\n");
+                return -1;
+        }
+}
+
+/* execute with input_lock locked */
+static int vino_is_input_owner(struct vino_channel_settings *vcs)
+{
+        switch(vcs->input) {
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+                return (vino_drvdata->decoder.owner == vcs->channel);
+        case VINO_INPUT_D1:
+                return (vino_drvdata->camera.owner == vcs->channel);
+        default:
+                return 0;
+        }
+}
+
+static int vino_acquire_input(struct vino_channel_settings *vcs)
+{
+        int ret = 0;
+
+        dprintk("vino_acquire_input():\n");
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        /* First try D1 and then SAA7191 */
+        if (vino_drvdata->camera.driver
+            && (vino_drvdata->camera.owner == VINO_NO_CHANNEL)) {
+                if (i2c_use_client(vino_drvdata->camera.driver)) {
+                        ret = -ENODEV;
+                        goto out;
+                }
+
+                vino_drvdata->camera.owner = vcs->channel;
+                vcs->input = VINO_INPUT_D1;
+                vcs->data_norm = VINO_DATA_NORM_D1;
+        } else if (vino_drvdata->decoder.driver
+                   && (vino_drvdata->decoder.owner == VINO_NO_CHANNEL)) {
+                int saa7191_input;
+                int saa7191_norm;
+
+                if (i2c_use_client(vino_drvdata->decoder.driver)) {
+                        ret = -ENODEV;
+                        goto out;
+                }
+
+                vino_drvdata->decoder.owner = vcs->channel;
+                vcs->input = VINO_INPUT_COMPOSITE;
+                vcs->data_norm = VINO_DATA_NORM_PAL;
+
+                saa7191_input = vino_get_saa7191_input(vcs->input);
+                i2c_decoder_command(DECODER_SET_INPUT, &saa7191_input);
+
+                saa7191_norm = vino_get_saa7191_norm(vcs->data_norm);
+                i2c_decoder_command(DECODER_SAA7191_SET_NORM, &saa7191_norm);
+        } else {
+                vcs->input = (vcs->channel == VINO_CHANNEL_A) ?
+                        vino_drvdata->b.input : vino_drvdata->a.input;
+                vcs->data_norm = (vcs->channel == VINO_CHANNEL_A) ?
+                        vino_drvdata->b.data_norm : vino_drvdata->a.data_norm;
+        }
+
+        if (vcs->input == VINO_INPUT_NONE) {
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (vino_is_input_owner(vcs)) {
+                vino_set_default_clipping(vcs);
+                vino_set_default_framerate(vcs);
+        }
+
+        dprintk("vino_acquire_input(): %s\n", vino_inputs[vcs->input].name);
+
+out:
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return ret;
+}
+
+static int vino_set_input(struct vino_channel_settings *vcs, int input)
+{
+        struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
+                &vino_drvdata->b : &vino_drvdata->a;
+        int ret = 0;
+
+        dprintk("vino_set_input():\n");
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        if (vcs->input == input)
+                goto out;
+
+        switch(input) {
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+                if (!vino_drvdata->decoder.driver) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                if (vino_drvdata->decoder.owner == VINO_NO_CHANNEL) {
+                        if (i2c_use_client(vino_drvdata->decoder.driver)) {
+                                ret = -ENODEV;
+                                goto out;
+                        }
+                        vino_drvdata->decoder.owner = vcs->channel;
+                }
+
+                if (vino_drvdata->decoder.owner == vcs->channel) {
+                        int saa7191_input;
+                        int saa7191_norm;
+
+                        vcs->input = input;
+                        vcs->data_norm = VINO_DATA_NORM_PAL;
+
+                        saa7191_input = vino_get_saa7191_input(vcs->input);
+                        i2c_decoder_command(DECODER_SET_INPUT, &saa7191_input);
+                        saa7191_norm = vino_get_saa7191_norm(vcs->data_norm);
+                        i2c_decoder_command(DECODER_SAA7191_SET_NORM,
+                                            &saa7191_norm);
+                } else {
+                        if (vcs2->input != input) {
+                                ret = -EBUSY;
+                                goto out;
+                        }
+
+                        vcs->input = input;
+                        vcs->data_norm = vcs2->data_norm;
+                }
+
+                if (vino_drvdata->camera.owner == vcs->channel) {
+                        /* Transfer the ownership or release the input */
+                        if (vcs2->input == VINO_INPUT_D1) {
+                                vino_drvdata->camera.owner = vcs2->channel;
+                        } else {
+                                i2c_release_client(vino_drvdata->
+                                                   camera.driver);
+                                vino_drvdata->camera.owner = VINO_NO_CHANNEL;
+                        }
+                }
+                break;
+        case VINO_INPUT_D1:
+                if (!vino_drvdata->camera.driver) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                if (vino_drvdata->camera.owner == VINO_NO_CHANNEL) {
+                        if (i2c_use_client(vino_drvdata->camera.driver)) {
+                                ret = -ENODEV;
+                                goto out;
+                        }
+                        vino_drvdata->camera.owner = vcs->channel;
+                }
+
+                if (vino_drvdata->decoder.owner == vcs->channel) {
+                        /* Transfer the ownership or release the input */
+                        if ((vcs2->input == VINO_INPUT_COMPOSITE) ||
+                                 (vcs2->input == VINO_INPUT_SVIDEO)) {
+                                vino_drvdata->decoder.owner = vcs2->channel;
+                        } else {
+                                i2c_release_client(vino_drvdata->
+                                                   decoder.driver);
+                                vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
+                        }
+                }
+
+                vcs->input = input;
+                vcs->data_norm = VINO_DATA_NORM_D1;
+                break;
+        default:
+                ret = -EINVAL;
+                goto out;
+        }
+
+        vino_set_default_clipping(vcs);
+        vino_set_default_framerate(vcs);
+
+        dprintk("vino_set_input(): %s\n", vino_inputs[vcs->input].name);
+
+out:
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return ret;
+}
+
+static void vino_release_input(struct vino_channel_settings *vcs)
+{
+        struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
+                &vino_drvdata->b : &vino_drvdata->a;
+
+        dprintk("vino_release_input():\n");
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        /* Release ownership of the channel
+         * and if the other channel takes input from
+         * the same source, transfer the ownership */
+        if (vino_drvdata->camera.owner == vcs->channel) {
+                if (vcs2->input == VINO_INPUT_D1) {
+                        vino_drvdata->camera.owner = vcs2->channel;
+                } else {
+                        i2c_release_client(vino_drvdata->camera.driver);
+                        vino_drvdata->camera.owner = VINO_NO_CHANNEL;
+                }
+        } else if (vino_drvdata->decoder.owner == vcs->channel) {
+                if ((vcs2->input == VINO_INPUT_COMPOSITE) ||
+                         (vcs2->input == VINO_INPUT_SVIDEO)) {
+                        vino_drvdata->decoder.owner = vcs2->channel;
+                } else {
+                        i2c_release_client(vino_drvdata->decoder.driver);
+                        vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
+                }
+        }
+        vcs->input = VINO_INPUT_NONE;
+
+        spin_unlock(&vino_drvdata->input_lock);
+}
+
+/* execute with input_lock locked */
+static int vino_set_data_norm(struct vino_channel_settings *vcs,
+                              unsigned int data_norm)
+{
+        int saa7191_norm;
+
+        switch (vcs->input) {
+        case VINO_INPUT_D1:
+                /* only one "norm" supported */
+                if (data_norm != VINO_DATA_NORM_D1)
+                        return -EINVAL;
+                break;
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+
+                saa7191_norm = vino_get_saa7191_norm(data_norm);
+
+                i2c_decoder_command(DECODER_SAA7191_SET_NORM, &saa7191_norm);
+                vcs->data_norm = data_norm;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* V4L2 helper functions */
+
+static int vino_find_data_format(__u32 pixelformat)
+{
+        int i;
+
+        for (i = 0; i < VINO_DATA_FMT_COUNT; i++) {
+                if (vino_data_formats[i].pixelformat == pixelformat)
+                        return i;
+        }
+
+        return VINO_DATA_FMT_NONE;
+}
+
+static int vino_enum_data_norm(struct vino_channel_settings *vcs, __u32 index)
+{
+        int data_norm = VINO_DATA_NORM_NONE;
+
+        spin_lock(&vino_drvdata->input_lock);
+        switch(vcs->input) {
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+                if (index == 0) {
+                        data_norm = VINO_DATA_NORM_PAL;
+                } else if (index == 1) {
+                        data_norm = VINO_DATA_NORM_NTSC;
+                } else if (index == 2) {
+                        data_norm = VINO_DATA_NORM_SECAM;
+                }
+                break;
+        case VINO_INPUT_D1:
+                if (index == 0) {
+                        data_norm = VINO_DATA_NORM_D1;
+                }
+                break;
+        }
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return data_norm;
+}
+
+static int vino_enum_input(struct vino_channel_settings *vcs, __u32 index)
+{
+        int input = VINO_INPUT_NONE;
+
+        spin_lock(&vino_drvdata->input_lock);
+        if (vino_drvdata->decoder.driver && vino_drvdata->camera.driver) {
+                switch (index) {
+                case 0:
+                        input = VINO_INPUT_COMPOSITE;
+                        break;
+                case 1:
+                        input = VINO_INPUT_SVIDEO;
+                        break;
+                case 2:
+                        input = VINO_INPUT_D1;
+                        break;
+                }
+        } else if (vino_drvdata->decoder.driver) {
+                switch (index) {
+                case 0:
+                        input = VINO_INPUT_COMPOSITE;
+                        break;
+                case 1:
+                        input = VINO_INPUT_SVIDEO;
+                        break;
+                }
+        } else if (vino_drvdata->camera.driver) {
+                switch (index) {
+                case 0:
+                        input = VINO_INPUT_D1;
+                        break;
+                }
+        }
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return input;
+}
+
+/* execute with input_lock locked */
+static __u32 vino_find_input_index(struct vino_channel_settings *vcs)
+{
+        __u32 index = 0;
+        // FIXME: detect when no inputs available
+
+        if (vino_drvdata->decoder.driver && vino_drvdata->camera.driver) {
+                switch (vcs->input) {
+                case VINO_INPUT_COMPOSITE:
+                        index = 0;
+                        break;
+                case VINO_INPUT_SVIDEO:
+                        index = 1;
+                        break;
+                case VINO_INPUT_D1:
+                        index = 2;
+                        break;
+                }
+        } else if (vino_drvdata->decoder.driver) {
+                switch (vcs->input) {
+                case VINO_INPUT_COMPOSITE:
+                        index = 0;
+                        break;
+                case VINO_INPUT_SVIDEO:
+                        index = 1;
+                        break;
+                }
+        } else if (vino_drvdata->camera.driver) {
+                switch (vcs->input) {
+                case VINO_INPUT_D1:
+                        index = 0;
+                        break;
+                }
+        }
+
+        return index;
+}
+
+/* V4L2 ioctls */
+
+static void vino_v4l2_querycap(struct v4l2_capability *cap)
+{
+        memset(cap, 0, sizeof(struct v4l2_capability));
+
+        strcpy(cap->driver, vino_driver_name);
+        strcpy(cap->card, vino_driver_description);
+        strcpy(cap->bus_info, vino_bus_name);
+        cap->version = VINO_VERSION_CODE;
+        cap->capabilities =
+                V4L2_CAP_VIDEO_CAPTURE |
+                V4L2_CAP_STREAMING;
+        // V4L2_CAP_OVERLAY, V4L2_CAP_READWRITE
+}
+
+static int vino_v4l2_enuminput(struct vino_channel_settings *vcs,
+                               struct v4l2_input *i)
+{
+        __u32 index = i->index;
+        int input;
+        dprintk("requested index = %d\n", index);
+
+        input = vino_enum_input(vcs, index);
+        if (input == VINO_INPUT_NONE)
+                return -EINVAL;
+
+        memset(i, 0, sizeof(struct v4l2_input));
+
+        i->index = index;
+        i->type = V4L2_INPUT_TYPE_CAMERA;
+        i->std = vino_inputs[input].std;
+        strcpy(i->name, vino_inputs[input].name);
+
+        if ((input == VINO_INPUT_COMPOSITE)
+            || (input == VINO_INPUT_SVIDEO)) {
+                struct saa7191_status status;
+                i2c_decoder_command(DECODER_SAA7191_GET_STATUS, &status);
+                i->status |= status.signal ? 0 : V4L2_IN_ST_NO_SIGNAL;
+                i->status |= status.color ? 0 : V4L2_IN_ST_NO_COLOR;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_g_input(struct vino_channel_settings *vcs,
+                             struct v4l2_input *i)
+{
+        __u32 index;
+        int input;
+
+        spin_lock(&vino_drvdata->input_lock);
+        input = vcs->input;
+        index = vino_find_input_index(vcs);
+        spin_unlock(&vino_drvdata->input_lock);
+
+        dprintk("input = %d\n", input);
+
+        if (input == VINO_INPUT_NONE) {
+                return -EINVAL;
+        }
+
+        memset(i, 0, sizeof(struct v4l2_input));
+
+        i->index = index;
+        i->type = V4L2_INPUT_TYPE_CAMERA;
+        i->std = vino_inputs[input].std;
+        strcpy(i->name, vino_inputs[input].name);
+
+        return 0;
+}
+
+static int vino_v4l2_s_input(struct vino_channel_settings *vcs,
+                             struct v4l2_input *i)
+{
+        int input;
+        dprintk("requested input = %d\n", i->index);
+
+        input = vino_enum_input(vcs, i->index);
+        if (input == VINO_INPUT_NONE)
+                return -EINVAL;
+
+        return vino_set_input(vcs, input);
+}
+
+static int vino_v4l2_enumstd(struct vino_channel_settings *vcs,
+                             struct v4l2_standard *s)
+{
+        int index = s->index;
+        int data_norm = vino_enum_data_norm(vcs, index);
+        dprintk("standard index = %d\n", index);
+
+        if (data_norm == VINO_DATA_NORM_NONE)
+                return -EINVAL;
+
+        dprintk("standard name = %s\n",
+               vino_data_norms[data_norm].description);
+
+        memset(s, 0, sizeof(struct v4l2_standard));
+        s->index = index;
+
+        s->id = vino_data_norms[data_norm].std;
+        s->frameperiod.numerator = 1;
+        s->frameperiod.denominator =
+                vino_data_norms[data_norm].fps_max;
+        s->framelines =
+                vino_data_norms[data_norm].framelines;
+        strcpy(s->name,
+               vino_data_norms[data_norm].description);
+
+        return 0;
+}
+
+static int vino_v4l2_g_std(struct vino_channel_settings *vcs,
+                           v4l2_std_id *std)
+{
+        spin_lock(&vino_drvdata->input_lock);
+        dprintk("current standard = %d\n", vcs->data_norm);
+        *std = vino_data_norms[vcs->data_norm].std;
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return 0;
+}
+
+static int vino_v4l2_s_std(struct vino_channel_settings *vcs,
+                           v4l2_std_id *std)
+{
+        int ret = 0;
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        /* check if the standard is valid for the current input */
+        if (vino_is_input_owner(vcs)
+            && (vino_inputs[vcs->input].std & (*std))) {
+                dprintk("standard accepted\n");
+
+                /* change the video norm for SAA7191
+                 * and accept NTSC for D1 (do nothing) */
+
+                if (vcs->input == VINO_INPUT_D1)
+                        goto out;
+
+                if ((*std) & V4L2_STD_PAL) {
+                        vino_set_data_norm(vcs, VINO_DATA_NORM_PAL);
+                        vcs->data_norm = VINO_DATA_NORM_PAL;
+                } else if ((*std) & V4L2_STD_NTSC) {
+                        vino_set_data_norm(vcs, VINO_DATA_NORM_NTSC);
+                        vcs->data_norm = VINO_DATA_NORM_NTSC;
+                } else if ((*std) & V4L2_STD_SECAM) {
+                        vino_set_data_norm(vcs, VINO_DATA_NORM_SECAM);
+                        vcs->data_norm = VINO_DATA_NORM_SECAM;
+                } else {
+                        ret = -EINVAL;
+                }
+        } else {
+                ret = -EINVAL;
+        }
+
+out:
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return ret;
+}
+
+static int vino_v4l2_enum_fmt(struct vino_channel_settings *vcs,
+                              struct v4l2_fmtdesc *fd)
+{
+        enum v4l2_buf_type type = fd->type;
+        int index = fd->index;
+        dprintk("format index = %d\n", index);
+
+        switch (fd->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                if ((fd->index < 0) ||
+                    (fd->index >= VINO_DATA_FMT_COUNT))
+                        return -EINVAL;
+                dprintk("format name = %s\n",
+                       vino_data_formats[index].description);
+
+                memset(fd, 0, sizeof(struct v4l2_fmtdesc));
+                fd->index = index;
+                fd->type = type;
+                fd->pixelformat = vino_data_formats[index].pixelformat;
+                strcpy(fd->description, vino_data_formats[index].description);
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_try_fmt(struct vino_channel_settings *vcs,
+                             struct v4l2_format *f)
+{
+        struct vino_channel_settings tempvcs;
+
+        switch (f->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct v4l2_pix_format *pf = &f->fmt.pix;
+
+                dprintk("requested: w = %d, h = %d\n",
+                       pf->width, pf->height);
+
+                spin_lock(&vino_drvdata->input_lock);
+                memcpy(&tempvcs, vcs, sizeof(struct vino_channel_settings));
+                spin_unlock(&vino_drvdata->input_lock);
+
+                tempvcs.data_format = vino_find_data_format(pf->pixelformat);
+                if (tempvcs.data_format == VINO_DATA_FMT_NONE) {
+                        tempvcs.data_format = VINO_DATA_FMT_RGB32;
+                        pf->pixelformat =
+                                vino_data_formats[tempvcs.data_format].
+                                pixelformat;
+                }
+
+                /* data format must be set before clipping/scaling */
+                vino_set_scaling(&tempvcs, pf->width, pf->height);
+
+                dprintk("data format = %s\n",
+                       vino_data_formats[tempvcs.data_format].description);
+
+                pf->width = (tempvcs.clipping.right - tempvcs.clipping.left) /
+                        tempvcs.decimation;
+                pf->height = (tempvcs.clipping.bottom - tempvcs.clipping.top) /
+                        tempvcs.decimation;
+
+                pf->field = V4L2_FIELD_INTERLACED;
+                pf->bytesperline = tempvcs.line_size;
+                pf->sizeimage = tempvcs.line_size *
+                        (tempvcs.clipping.bottom - tempvcs.clipping.top) /
+                        tempvcs.decimation;
+                pf->colorspace =
+                        vino_data_formats[tempvcs.data_format].colorspace;
+
+                pf->priv = 0;
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_g_fmt(struct vino_channel_settings *vcs,
+                           struct v4l2_format *f)
+{
+        switch (f->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct v4l2_pix_format *pf = &f->fmt.pix;
+                spin_lock(&vino_drvdata->input_lock);
+
+                pf->width = (vcs->clipping.right - vcs->clipping.left) /
+                        vcs->decimation;
+                pf->height = (vcs->clipping.bottom - vcs->clipping.top) /
+                        vcs->decimation;
+                pf->pixelformat =
+                        vino_data_formats[vcs->data_format].pixelformat;
+
+                pf->field = V4L2_FIELD_INTERLACED;
+                pf->bytesperline = vcs->line_size;
+                pf->sizeimage = vcs->line_size *
+                        (vcs->clipping.bottom - vcs->clipping.top) /
+                        vcs->decimation;
+                pf->colorspace =
+                        vino_data_formats[vcs->data_format].colorspace;
+
+                pf->priv = 0;
+
+                spin_unlock(&vino_drvdata->input_lock);
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_s_fmt(struct vino_channel_settings *vcs,
+                           struct v4l2_format *f)
+{
+        int data_format;
+
+        switch (f->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct v4l2_pix_format *pf = &f->fmt.pix;
+                spin_lock(&vino_drvdata->input_lock);
+
+                if (!vino_is_input_owner(vcs)) {
+                        spin_unlock(&vino_drvdata->input_lock);
+                        return -EINVAL;
+                }
+
+                data_format = vino_find_data_format(pf->pixelformat);
+                if (data_format == VINO_DATA_FMT_NONE) {
+                        vcs->data_format = VINO_DATA_FMT_RGB32;
+                        pf->pixelformat =
+                                vino_data_formats[vcs->data_format].
+                                pixelformat;
+                } else {
+                        vcs->data_format = data_format;
+                }
+
+                /* data format must be set before clipping/scaling */
+                vino_set_scaling(vcs, pf->width, pf->height);
+
+                dprintk("data format = %s\n",
+                       vino_data_formats[vcs->data_format].description);
+
+                pf->width = vcs->clipping.right - vcs->clipping.left;
+                pf->height = vcs->clipping.bottom - vcs->clipping.top;
+
+                pf->field = V4L2_FIELD_INTERLACED;
+                pf->bytesperline = vcs->line_size;
+                pf->sizeimage = vcs->line_size *
+                        (vcs->clipping.bottom - vcs->clipping.top) /
+                        vcs->decimation;
+                pf->colorspace =
+                        vino_data_formats[vcs->data_format].colorspace;
+
+                pf->priv = 0;
+
+                spin_unlock(&vino_drvdata->input_lock);
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_cropcap(struct vino_channel_settings *vcs,
+                             struct v4l2_cropcap *ccap)
+{
+        const struct vino_data_norm *norm;
+
+        switch (ccap->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                spin_lock(&vino_drvdata->input_lock);
+                norm = &vino_data_norms[vcs->data_norm];
+                spin_unlock(&vino_drvdata->input_lock);
+
+                ccap->bounds.left = 0;
+                ccap->bounds.top = 0;
+                ccap->bounds.width = norm->width;
+                ccap->bounds.height = norm->height;
+                memcpy(&ccap->defrect, &ccap->bounds,
+                       sizeof(struct v4l2_rect));
+
+                ccap->pixelaspect.numerator = 1;
+                ccap->pixelaspect.denominator = 1;
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_g_crop(struct vino_channel_settings *vcs,
+                            struct v4l2_crop *c)
+{
+        switch (c->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                spin_lock(&vino_drvdata->input_lock);
+
+                c->c.left = vcs->clipping.left;
+                c->c.top = vcs->clipping.top;
+                c->c.width = vcs->clipping.right - vcs->clipping.left;
+                c->c.height = vcs->clipping.bottom - vcs->clipping.top;
+
+                spin_unlock(&vino_drvdata->input_lock);
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_s_crop(struct vino_channel_settings *vcs,
+                            struct v4l2_crop *c)
+{
+        switch (c->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                spin_lock(&vino_drvdata->input_lock);
+
+                if (!vino_is_input_owner(vcs)) {
+                        spin_unlock(&vino_drvdata->input_lock);
+                        return -EINVAL;
+                }
+                vino_set_clipping(vcs, c->c.left, c->c.top,
+                                  c->c.width, c->c.height);
+
+                spin_unlock(&vino_drvdata->input_lock);
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_g_parm(struct vino_channel_settings *vcs,
+                            struct v4l2_streamparm *sp)
+{
+        switch (sp->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct v4l2_captureparm *cp = &sp->parm.capture;
+                memset(cp, 0, sizeof(struct v4l2_captureparm));
+
+                cp->capability = V4L2_CAP_TIMEPERFRAME;
+                cp->timeperframe.numerator = 1;
+
+                spin_lock(&vino_drvdata->input_lock);
+                cp->timeperframe.denominator = vcs->fps;
+                spin_unlock(&vino_drvdata->input_lock);
+
+                // TODO: cp->readbuffers = xxx;
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_s_parm(struct vino_channel_settings *vcs,
+                            struct v4l2_streamparm *sp)
+{
+        switch (sp->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct v4l2_captureparm *cp = &sp->parm.capture;
+
+                spin_lock(&vino_drvdata->input_lock);
+                if (!vino_is_input_owner(vcs)) {
+                        spin_unlock(&vino_drvdata->input_lock);
+                        return -EINVAL;
+                }
+
+                if ((cp->timeperframe.numerator == 0) ||
+                    (cp->timeperframe.denominator == 0)) {
+                        /* reset framerate */
+                        vino_set_default_framerate(vcs);
+                } else {
+                        vino_set_framerate(vcs, cp->timeperframe.denominator /
+                                           cp->timeperframe.numerator);
+                }
+                spin_unlock(&vino_drvdata->input_lock);
+
+                // TODO: set buffers according to cp->readbuffers
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_reqbufs(struct vino_channel_settings *vcs,
+                             struct v4l2_requestbuffers *rb)
+{
+        if (vcs->reading)
+                return -EBUSY;
+
+        switch (rb->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                // TODO: check queue type
+                if (rb->memory != V4L2_MEMORY_MMAP) {
+                        dprintk("type not mmap\n");
+                        return -EINVAL;
+                }
+
+                if (vino_is_capturing(vcs)) {
+                        dprintk("busy, capturing\n");
+                        return -EBUSY;
+                }
+
+                dprintk("count = %d\n", rb->count);
+                if (rb->count > 0) {
+                        if (vino_queue_has_mapped_buffers(&vcs->fb_queue)) {
+                                dprintk("busy, buffers still mapped\n");
+                                return -EBUSY;
+                        } else {
+                                vino_queue_free(&vcs->fb_queue);
+                                vino_queue_init(&vcs->fb_queue, &rb->count);
+                        }
+                } else {
+                        vino_capture_stop(vcs);
+                        vino_queue_free(&vcs->fb_queue);
+                }
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void vino_v4l2_get_buffer_status(struct vino_channel_settings *vcs,
+                                        struct vino_framebuffer *fb,
+                                        struct v4l2_buffer *b)
+{
+        if (vino_queue_outgoing_contains(&vcs->fb_queue,
+                                         fb->id)) {
+                b->flags &= ~V4L2_BUF_FLAG_QUEUED;
+                b->flags |= V4L2_BUF_FLAG_DONE;
+        } else if (vino_queue_incoming_contains(&vcs->fb_queue,
+                                       fb->id)) {
+                b->flags &= ~V4L2_BUF_FLAG_DONE;
+                b->flags |= V4L2_BUF_FLAG_QUEUED;
+        } else {
+                b->flags &= ~(V4L2_BUF_FLAG_DONE |
+                              V4L2_BUF_FLAG_QUEUED);
+        }
+
+        b->flags &= ~(V4L2_BUF_FLAG_TIMECODE);
+
+        if (fb->map_count > 0)
+                b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+        b->index = fb->id;
+        b->memory = (vcs->fb_queue.type == VINO_MEMORY_MMAP) ?
+                V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
+        b->m.offset = fb->offset;
+        b->bytesused = fb->data_size;
+        b->length = fb->size;
+        b->field = V4L2_FIELD_INTERLACED;
+        b->sequence = fb->frame_counter;
+        memcpy(&b->timestamp, &fb->timestamp,
+               sizeof(struct timeval));
+        // b->input ?
+
+        dprintk("buffer %d: length = %d, bytesused = %d, offset = %d\n",
+                fb->id, fb->size, fb->data_size, fb->offset);
+}
+
+static int vino_v4l2_querybuf(struct vino_channel_settings *vcs,
+                              struct v4l2_buffer *b)
+{
+        if (vcs->reading)
+                return -EBUSY;
+
+        switch (b->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct vino_framebuffer *fb;
+
+                // TODO: check queue type
+                if (b->index >= vino_queue_get_length(&vcs->fb_queue)) {
+                        dprintk("invalid index = %d\n",
+                               b->index);
+                        return -EINVAL;
+                }
+
+                fb = vino_queue_get_buffer(&vcs->fb_queue,
+                                           b->index);
+                if (fb == NULL) {
+                        dprintk("vino_queue_get_buffer() failed");
+                        return -EINVAL;
+                }
+
+                vino_v4l2_get_buffer_status(vcs, fb, b);
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_qbuf(struct vino_channel_settings *vcs,
+                          struct v4l2_buffer *b)
+{
+        if (vcs->reading)
+                return -EBUSY;
+
+        switch (b->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct vino_framebuffer *fb;
+                int ret;
+
+                // TODO: check queue type
+                if (b->memory != V4L2_MEMORY_MMAP) {
+                        dprintk("type not mmap\n");
+                        return -EINVAL;
+                }
+
+                fb = vino_capture_enqueue(vcs, b->index);
+                if (fb == NULL)
+                        return -EINVAL;
+
+                vino_v4l2_get_buffer_status(vcs, fb, b);
+
+                if (vcs->streaming) {
+                        ret = vino_capture_next(vcs, 1);
+                        if (ret)
+                                return ret;
+                }
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_dqbuf(struct vino_channel_settings *vcs,
+                           struct v4l2_buffer *b,
+                           unsigned int nonblocking)
+{
+        if (vcs->reading)
+                return -EBUSY;
+
+        switch (b->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
+                struct vino_framebuffer *fb;
+                unsigned int incoming, outgoing;
+                int err;
+
+                // TODO: check queue type
+
+                err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
+                if (err) {
+                        dprintk("vino_queue_get_incoming() failed\n");
+                        return -EIO;
+                }
+                err = vino_queue_get_outgoing(&vcs->fb_queue, &outgoing);
+                if (err) {
+                        dprintk("vino_queue_get_outgoing() failed\n");
+                        return -EIO;
+                }
+
+                dprintk("incoming = %d, outgoing = %d\n", incoming, outgoing);
+
+                if (outgoing == 0) {
+                        if (incoming == 0) {
+                                dprintk("no incoming or outgoing buffers\n");
+                                return -EINVAL;
+                        }
+                        if (nonblocking) {
+                                dprintk("non-blocking I/O was selected and "
+                                        "there are no buffers to dequeue\n");
+                                return -EAGAIN;
+                        }
+
+                        err = vino_wait_for_frame(vcs);
+                        if (err) {
+                                err = vino_wait_for_frame(vcs);
+                                if (err) {
+                                        /* interrupted */
+                                        vino_capture_failed(vcs);
+                                        return -EIO;
+                                }
+                        }
+                }
+
+                fb = vino_queue_remove(&vcs->fb_queue, &b->index);
+                if (fb == NULL) {
+                        dprintk("vino_queue_remove() failed\n");
+                        return -EINVAL;
+                }
+
+                err = vino_check_buffer(vcs, fb);
+                if (err)
+                        return -EIO;
+
+                vino_v4l2_get_buffer_status(vcs, fb, b);
+                break;
+        }
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_streamon(struct vino_channel_settings *vcs)
+{
+        unsigned int incoming;
+        int ret;
+        if (vcs->reading)
+                return -EBUSY;
+
+        if (vcs->streaming)
+                return 0;
+
+        // TODO: check queue type
+
+        if (vino_queue_get_length(&vcs->fb_queue) < 1) {
+                dprintk("no buffers allocated\n");
+                return -EINVAL;
+        }
+
+        ret = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
+        if (ret) {
+                dprintk("vino_queue_get_incoming() failed\n");
+                return -EINVAL;
+        }
+
+        vcs->streaming = 1;
+
+        if (incoming > 0) {
+                ret = vino_capture_next(vcs, 1);
+                if (ret) {
+                        vcs->streaming = 0;
+
+                        dprintk("couldn't start capture\n");
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
+static int vino_v4l2_streamoff(struct vino_channel_settings *vcs)
+{
+        if (vcs->reading)
+                return -EBUSY;
+
+        if (!vcs->streaming)
+                return 0;
+
+        vino_capture_stop(vcs);
+        vcs->streaming = 0;
+
+        return 0;
+}
+
+static int vino_v4l2_queryctrl(struct vino_channel_settings *vcs,
+                               struct v4l2_queryctrl *queryctrl)
+{
+        int i;
+        int err = 0;
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        switch (vcs->input) {
+        case VINO_INPUT_D1:
+                for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
+                        if (vino_indycam_v4l2_controls[i].id ==
+                            queryctrl->id) {
+                                memcpy(queryctrl,
+                                       &vino_indycam_v4l2_controls[i],
+                                       sizeof(struct v4l2_queryctrl));
+                                goto found;
+                        }
+                }
+
+                err =  -EINVAL;
+                break;
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+                for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
+                        if (vino_saa7191_v4l2_controls[i].id ==
+                            queryctrl->id) {
+                                memcpy(queryctrl,
+                                       &vino_saa7191_v4l2_controls[i],
+                                       sizeof(struct v4l2_queryctrl));
+                                goto found;
+                        }
+                }
+
+                err =  -EINVAL;
+                break;
+        default:
+                err =  -EINVAL;
+        }
+
+ found:
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return err;
+}
+
+static int vino_v4l2_g_ctrl(struct vino_channel_settings *vcs,
+                            struct v4l2_control *control)
+{
+        struct indycam_control indycam_ctrl;
+        struct saa7191_control saa7191_ctrl;
+        int err = 0;
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        switch (vcs->input) {
+        case VINO_INPUT_D1:
+                i2c_camera_command(DECODER_INDYCAM_GET_CONTROLS,
+                                   &indycam_ctrl);
+
+                switch(control->id) {
+                case V4L2_CID_AUTOGAIN:
+                        control->value = indycam_ctrl.agc;
+                        break;
+                case V4L2_CID_AUTO_WHITE_BALANCE:
+                        control->value = indycam_ctrl.awb;
+                        break;
+                case V4L2_CID_GAIN:
+                        control->value = indycam_ctrl.gain;
+                        break;
+                case V4L2_CID_PRIVATE_BASE:
+                        control->value = indycam_ctrl.red_saturation;
+                        break;
+                case V4L2_CID_PRIVATE_BASE + 1:
+                        control->value = indycam_ctrl.blue_saturation;
+                        break;
+                case V4L2_CID_RED_BALANCE:
+                        control->value = indycam_ctrl.red_balance;
+                        break;
+                case V4L2_CID_BLUE_BALANCE:
+                        control->value = indycam_ctrl.blue_balance;
+                        break;
+                case V4L2_CID_EXPOSURE:
+                        control->value = indycam_ctrl.shutter;
+                        break;
+                case V4L2_CID_GAMMA:
+                        control->value = indycam_ctrl.gamma;
+                        break;
+                default:
+                        err = -EINVAL;
+                }
+                break;
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+                i2c_decoder_command(DECODER_SAA7191_GET_CONTROLS,
+                                   &saa7191_ctrl);
+
+                switch(control->id) {
+                case V4L2_CID_HUE:
+                        control->value = saa7191_ctrl.hue;
+                        break;
+                case V4L2_CID_PRIVATE_BASE:
+                        control->value = saa7191_ctrl.vtrc;
+                        break;
+                default:
+                        err = -EINVAL;
+                }
+                break;
+        default:
+                err =  -EINVAL;
+        }
+
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return err;
+}
+
+static int vino_v4l2_s_ctrl(struct vino_channel_settings *vcs,
+                            struct v4l2_control *control)
+{
+        struct indycam_control indycam_ctrl;
+        struct saa7191_control saa7191_ctrl;
+        int i;
+        int err = 0;
+
+        spin_lock(&vino_drvdata->input_lock);
+
+        switch (vcs->input) {
+        case VINO_INPUT_D1:
+                for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
+                        if (vino_indycam_v4l2_controls[i].id ==
+                            control->id) {
+                                if ((control->value >=
+                                     vino_indycam_v4l2_controls[i].minimum)
+                                    && (control->value <=
+                                        vino_indycam_v4l2_controls[i].
+                                        maximum)) {
+                                        goto ok1;
+                                } else {
+                                        err = -ERANGE;
+                                        goto error;
+                                }
+                        }
+                }
+                err = -EINVAL;
+                goto error;
+
+ok1:
+                indycam_ctrl.agc = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.awb = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.shutter = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.gain = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.red_balance = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.blue_balance = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.red_saturation = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.blue_saturation = INDYCAM_VALUE_UNCHANGED;
+                indycam_ctrl.gamma = INDYCAM_VALUE_UNCHANGED;
+
+                switch(control->id) {
+                case V4L2_CID_AUTOGAIN:
+                        indycam_ctrl.agc = control->value;
+                        break;
+                case V4L2_CID_AUTO_WHITE_BALANCE:
+                        indycam_ctrl.awb = control->value;
+                        break;
+                case V4L2_CID_GAIN:
+                        indycam_ctrl.gain = control->value;
+                        break;
+                case V4L2_CID_PRIVATE_BASE:
+                        indycam_ctrl.red_saturation = control->value;
+                        break;
+                case V4L2_CID_PRIVATE_BASE + 1:
+                        indycam_ctrl.blue_saturation = control->value;
+                        break;
+                case V4L2_CID_RED_BALANCE:
+                        indycam_ctrl.red_balance = control->value;
+                        break;
+                case V4L2_CID_BLUE_BALANCE:
+                        indycam_ctrl.blue_balance = control->value;
+                        break;
+                case V4L2_CID_EXPOSURE:
+                        indycam_ctrl.shutter = control->value;
+                        break;
+                case V4L2_CID_GAMMA:
+                        indycam_ctrl.gamma = control->value;
+                        break;
+                default:
+                        err =  -EINVAL;
+                }
+
+                if (!err)
+                        i2c_camera_command(DECODER_INDYCAM_SET_CONTROLS,
+                                           &indycam_ctrl);
+                break;
+        case VINO_INPUT_COMPOSITE:
+        case VINO_INPUT_SVIDEO:
+                for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
+                        if (vino_saa7191_v4l2_controls[i].id ==
+                            control->id) {
+                                if ((control->value >=
+                                     vino_saa7191_v4l2_controls[i].minimum)
+                                    && (control->value <=
+                                        vino_saa7191_v4l2_controls[i].
+                                        maximum)) {
+                                        goto ok2;
+                                } else {
+                                        err = -ERANGE;
+                                        goto error;
+                                }
+                        }
+                }
+                err = -EINVAL;
+                goto error;
+
+ok2:
+                saa7191_ctrl.hue = SAA7191_VALUE_UNCHANGED;
+                saa7191_ctrl.vtrc = SAA7191_VALUE_UNCHANGED;
+
+                switch(control->id) {
+                case V4L2_CID_HUE:
+                        saa7191_ctrl.hue = control->value;
+                        break;
+                case V4L2_CID_PRIVATE_BASE:
+                        saa7191_ctrl.vtrc = control->value;
+                        break;
+                default:
+                        err =  -EINVAL;
+                }
+
+                if (!err)
+                        i2c_decoder_command(DECODER_SAA7191_SET_CONTROLS,
+                                            &saa7191_ctrl);
+                break;
+        default:
+                err =  -EINVAL;
+        }
+
+error:
+        spin_unlock(&vino_drvdata->input_lock);
+
+        return err;
+}
+
+/* File operations */
+
+static int vino_open(struct inode *inode, struct file *file)
+{
+        struct video_device *dev = video_devdata(file);
+        struct vino_channel_settings *vcs = video_get_drvdata(dev);
+        int ret = 0;
+        dprintk("open(): channel = %c\n",
+               (vcs->channel == VINO_CHANNEL_A) ? 'A' : 'B');
+
+        down(&vcs->sem);
+
+        if (vcs->users) {
+                dprintk("open(): driver busy\n");
+                ret = -EBUSY;
+                goto out;
+        }
+
+        ret = vino_acquire_input(vcs);
+        if (ret) {
+                dprintk("open(): vino_acquire_input() failed\n");
+                goto out;
+        }
+
+        vcs->users++;
+
+ out:
+        up(&vcs->sem);
+
+        dprintk("open(): %s!\n", ret ? "failed" : "complete");
+
+        return ret;
+}
+
+static int vino_close(struct inode *inode, struct file *file)
+{
+        struct video_device *dev = video_devdata(file);
+        struct vino_channel_settings *vcs = video_get_drvdata(dev);
+        dprintk("close():\n");
+
+        down(&vcs->sem);
+
+        vcs->users--;
+
+        if (!vcs->users) {
+                vino_release_input(vcs);
+
+                /* stop DMA and free buffers */
+                vino_capture_stop(vcs);
+                vino_queue_free(&vcs->fb_queue);
+        }
+
+        up(&vcs->sem);
+
+        return 0;
+}
+
+static void vino_vm_open(struct vm_area_struct *vma)
+{
+        struct vino_framebuffer *fb = vma->vm_private_data;
+
+        fb->map_count++;
+        dprintk("vino_vm_open(): count = %d\n", fb->map_count);
+}
+
+static void vino_vm_close(struct vm_area_struct *vma)
+{
+        struct vino_framebuffer *fb = vma->vm_private_data;
+
+        fb->map_count--;
+        dprintk("vino_vm_close(): count = %d\n", fb->map_count);
+}
+
+static struct vm_operations_struct vino_vm_ops = {
+        .open   = vino_vm_open,
+        .close  = vino_vm_close,
+};
+
+static int vino_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct video_device *dev = video_devdata(file);
+        struct vino_channel_settings *vcs = video_get_drvdata(dev);
+
+        unsigned long start = vma->vm_start;
+        unsigned long size = vma->vm_end - vma->vm_start;
+        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+
+        struct vino_framebuffer *fb = NULL;
+        unsigned int i, length;
+        int ret = 0;
+
+        dprintk("mmap():\n");
+
+        // TODO: reject mmap if already mapped
+
+        if (down_interruptible(&vcs->sem))
+                return -EINTR;
+
+        if (vcs->reading) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        // TODO: check queue type
+
+        if (!(vma->vm_flags & VM_WRITE)) {
+                dprintk("mmap(): app bug: PROT_WRITE please\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        if (!(vma->vm_flags & VM_SHARED)) {
+                dprintk("mmap(): app bug: MAP_SHARED please\n");
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* find the correct buffer using offset */
+        length = vino_queue_get_length(&vcs->fb_queue);
+        if (length == 0) {
+                dprintk("mmap(): queue not initialized\n");
+                ret = -EINVAL;
+                goto out;
+        }
+
+        for (i = 0; i < length; i++) {
+                fb = vino_queue_get_buffer(&vcs->fb_queue, i);
+                if (fb == NULL) {
+                        dprintk("mmap(): vino_queue_get_buffer() failed\n");
+                        ret = -EINVAL;
+                        goto out;
+                }
+
+                if (fb->offset == offset)
+                        goto found;
+        }
+
+        dprintk("mmap(): invalid offset = %lu\n", offset);
+        ret = -EINVAL;
+        goto out;
+
+found:
+        dprintk("mmap(): buffer = %d\n", i);
+
+        if (size > (fb->desc_table.page_count * PAGE_SIZE)) {
+                dprintk("mmap(): failed: size = %lu > %lu\n",
+                        size, fb->desc_table.page_count * PAGE_SIZE);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        for (i = 0; i < fb->desc_table.page_count; i++) {
+                unsigned long pfn =
+                        virt_to_phys((void *)fb->desc_table.virtual[i]) >>
+                        PAGE_SHIFT;
+
+                if (size < PAGE_SIZE)
+                        break;
+
+                // protection was: PAGE_READONLY
+                if (remap_pfn_range(vma, start, pfn, PAGE_SIZE,
+                                    vma->vm_page_prot)) {
+                        dprintk("mmap(): remap_pfn_range() failed\n");
+                        ret = -EAGAIN;
+                        goto out;
+                }
+
+                start += PAGE_SIZE;
+                size -= PAGE_SIZE;
+        }
+
+        fb->map_count = 1;
+
+        vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
+        vma->vm_flags &= ~VM_IO;
+        vma->vm_private_data = fb;
+        vma->vm_file = file;
+        vma->vm_ops = &vino_vm_ops;
+
+out:
+        up(&vcs->sem);
+
+        return ret;
+}
+
+static unsigned int vino_poll(struct file *file, poll_table *pt)
+{
+        struct video_device *dev = video_devdata(file);
+        struct vino_channel_settings *vcs = video_get_drvdata(dev);
+        unsigned int outgoing;
+        unsigned int ret = 0;
+
+        // lock mutex (?)
+        // TODO: this has to be corrected for different read modes
+
+        dprintk("poll():\n");
+
+        if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
+                dprintk("poll(): vino_queue_get_outgoing() failed\n");
+                ret = POLLERR;
+                goto error;
+        }
+        if (outgoing > 0)
+                goto over;
+
+        poll_wait(file, &vcs->fb_queue.frame_wait_queue, pt);
+
+        if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
+                dprintk("poll(): vino_queue_get_outgoing() failed\n");
+                ret = POLLERR;
+                goto error;
+        }
+
+over:
+        dprintk("poll(): data %savailable\n",
+                (outgoing > 0) ? "" : "not ");
+        if (outgoing > 0) {
+                ret = POLLIN | POLLRDNORM;
+        }
+
+error:
+
+        return ret;
+}
+
+static int vino_do_ioctl(struct inode *inode, struct file *file,
+                      unsigned int cmd, void *arg)
+{
+        struct video_device *dev = video_devdata(file);
+        struct vino_channel_settings *vcs = video_get_drvdata(dev);
+
+        switch (_IOC_TYPE(cmd)) {
+        case 'v':
+                dprintk("ioctl(): V4L1 unsupported (0x%08x)\n", cmd);
+                break;
+        case 'V':
+                dprintk("ioctl(): V4L2 %s (0x%08x)\n",
+                        v4l2_ioctl_names[_IOC_NR(cmd)], cmd);
+                break;
+        default:
+                dprintk("ioctl(): unsupported command 0x%08x\n", cmd);
+        }
+
+        switch (cmd) {
+        /* TODO: V4L1 interface (use compatibility layer?) */
+        /* V4L2 interface */
+        case VIDIOC_QUERYCAP: {
+                vino_v4l2_querycap(arg);
+                break;
+        }
+        case VIDIOC_ENUMINPUT: {
+                return vino_v4l2_enuminput(vcs, arg);
+        }
+        case VIDIOC_G_INPUT: {
+                return vino_v4l2_g_input(vcs, arg);
+        }
+        case VIDIOC_S_INPUT: {
+                return vino_v4l2_s_input(vcs, arg);
+        }
+        case VIDIOC_ENUMSTD: {
+                return vino_v4l2_enumstd(vcs, arg);
+        }
+        case VIDIOC_G_STD: {
+                return vino_v4l2_g_std(vcs, arg);
+        }
+        case VIDIOC_S_STD: {
+                return vino_v4l2_s_std(vcs, arg);
+        }
+        case VIDIOC_ENUM_FMT: {
+                return vino_v4l2_enum_fmt(vcs, arg);
+        }
+        case VIDIOC_TRY_FMT: {
+                return vino_v4l2_try_fmt(vcs, arg);
+        }
+        case VIDIOC_G_FMT: {
+                return vino_v4l2_g_fmt(vcs, arg);
+        }
+        case VIDIOC_S_FMT: {
+                return vino_v4l2_s_fmt(vcs, arg);
+        }
+        case VIDIOC_CROPCAP: {
+                return vino_v4l2_cropcap(vcs, arg);
+        }
+        case VIDIOC_G_CROP: {
+                return vino_v4l2_g_crop(vcs, arg);
+        }
+        case VIDIOC_S_CROP: {
+                return vino_v4l2_s_crop(vcs, arg);
+        }
+        case VIDIOC_G_PARM: {
+                return vino_v4l2_g_parm(vcs, arg);
+        }
+        case VIDIOC_S_PARM: {
+                return vino_v4l2_s_parm(vcs, arg);
+        }
+        case VIDIOC_REQBUFS: {
+                return vino_v4l2_reqbufs(vcs, arg);
+        }
+        case VIDIOC_QUERYBUF: {
+                return vino_v4l2_querybuf(vcs, arg);
+        }
+        case VIDIOC_QBUF: {
+                return vino_v4l2_qbuf(vcs, arg);
+        }
+        case VIDIOC_DQBUF: {
+                return vino_v4l2_dqbuf(vcs, arg, file->f_flags & O_NONBLOCK);
+        }
+        case VIDIOC_STREAMON: {
+                return vino_v4l2_streamon(vcs);
+        }
+        case VIDIOC_STREAMOFF: {
+                return vino_v4l2_streamoff(vcs);
+        }
+        case VIDIOC_QUERYCTRL: {
+                return vino_v4l2_queryctrl(vcs, arg);
+        }
+        case VIDIOC_G_CTRL: {
+                return vino_v4l2_g_ctrl(vcs, arg);
+        }
+        case VIDIOC_S_CTRL: {
+                return vino_v4l2_s_ctrl(vcs, arg);
+        }
+        default:
+                return -ENOIOCTLCMD;
+        }
+
+        return 0;
+}
+
+static int vino_ioctl(struct inode *inode, struct file *file,
+                      unsigned int cmd, unsigned long arg)
+{
+        struct video_device *dev = video_devdata(file);
+        struct vino_channel_settings *vcs = video_get_drvdata(dev);
+        int ret;
+
+        if (down_interruptible(&vcs->sem))
+                return -EINTR;
+
+        ret = video_usercopy(inode, file, cmd, arg, vino_do_ioctl);
+
+        up(&vcs->sem);
+
+        return ret;
+}
+
+/* Initialization and cleanup */
+
+// __initdata
+static int vino_init_stage = 0;
+
+static struct file_operations vino_fops = {
         .owner          = THIS_MODULE,
-        .type           = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE,
-        .hardware       = VID_HARDWARE_VINO,
-        .name           = "VINO",
         .open           = vino_open,
-        .close          = vino_close,
+        .release        = vino_close,
         .ioctl          = vino_ioctl,
         .mmap           = vino_mmap,
+        .poll           = vino_poll,
+        .llseek         = no_llseek,
 };
 
-static int __init vino_init(void)
+static struct video_device v4l_device_template = {
+        .name           = "NOT SET",
+        //.type         = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE |
+        //      VID_TYPE_CLIPPING | VID_TYPE_SCALES, VID_TYPE_OVERLAY
+        .hardware       = VID_HARDWARE_VINO,
+        .fops           = &vino_fops,
+        .minor          = -1,
+};
+
+static void vino_module_cleanup(int stage)
+{
+        switch(stage) {
+        case 10:
+                video_unregister_device(vino_drvdata->b.v4l_device);
+                vino_drvdata->b.v4l_device = NULL;
+        case 9:
+                video_unregister_device(vino_drvdata->a.v4l_device);
+                vino_drvdata->a.v4l_device = NULL;
+        case 8:
+                vino_i2c_del_bus();
+        case 7:
+                free_irq(SGI_VINO_IRQ, NULL);
+        case 6:
+                if (vino_drvdata->b.v4l_device) {
+                        video_device_release(vino_drvdata->b.v4l_device);
+                        vino_drvdata->b.v4l_device = NULL;
+                }
+        case 5:
+                if (vino_drvdata->a.v4l_device) {
+                        video_device_release(vino_drvdata->a.v4l_device);
+                        vino_drvdata->a.v4l_device = NULL;
+                }
+        case 4:
+                /* all entries in dma_cpu dummy table have the same address */
+                dma_unmap_single(NULL,
+                                 vino_drvdata->dummy_desc_table.dma_cpu[0],
+                                 PAGE_SIZE, DMA_FROM_DEVICE);
+                dma_free_coherent(NULL, VINO_DUMMY_DESC_COUNT
+                                  * sizeof(dma_addr_t),
+                                  (void *)vino_drvdata->
+                                  dummy_desc_table.dma_cpu,
+                                  vino_drvdata->dummy_desc_table.dma);
+        case 3:
+                free_page(vino_drvdata->dummy_page);
+        case 2:
+                kfree(vino_drvdata);
+        case 1:
+                iounmap(vino);
+        case 0:
+                break;
+        default:
+                dprintk("vino_module_cleanup(): invalid cleanup stage = %d\n",
+                        stage);
+        }
+}
+
+static int vino_probe(void)
 {
-        unsigned long rev;
-        int i, ret = 0;
+        unsigned long rev_id;
 
-        /* VINO is Indy specific beast */
-        if (ip22_is_fullhouse())
+        if (ip22_is_fullhouse()) {
+                printk(KERN_ERR "VINO doesn't exist in IP22 Fullhouse\n");
                 return -ENODEV;
+        }
 
-        /*
-         * VINO is in the EISA address space, so the sysid register will tell
-         * us if the EISA_PRESENT pin on MC has been pulled low.
-         *
-         * If EISA_PRESENT is not set we definitely don't have a VINO equiped
-         * system.
-         */
         if (!(sgimc->systemid & SGIMC_SYSID_EPRESENT)) {
-                printk(KERN_ERR "VINO not found\n");
+                printk(KERN_ERR "VINO is not found (EISA BUS not present)\n");
                 return -ENODEV;
         }
 
         vino = (struct sgi_vino *)ioremap(VINO_BASE, sizeof(struct sgi_vino));
-        if (!vino)
+        if (!vino) {
+                printk(KERN_ERR "VINO: ioremap() failed\n");
                 return -EIO;
+        }
+        vino_init_stage++;
 
-        /* Okay, once we know that VINO is present we'll read its revision
-         * safe way. One never knows... */
-        if (get_dbe(rev, &(vino->rev_id))) {
-                printk(KERN_ERR "VINO: failed to read revision register\n");
-                ret = -ENODEV;
-                goto out_unmap;
+        if (get_dbe(rev_id, &(vino->rev_id))) {
+                printk(KERN_ERR "Failed to read VINO revision register\n");
+                vino_module_cleanup(vino_init_stage);
+                return -ENODEV;
         }
-        if (VINO_ID_VALUE(rev) != VINO_CHIP_ID) {
-                printk(KERN_ERR "VINO is not VINO (Rev/ID: 0x%04lx)\n", rev);
-                ret = -ENODEV;
-                goto out_unmap;
+
+        if (VINO_ID_VALUE(rev_id) != VINO_CHIP_ID) {
+                printk(KERN_ERR "Unknown VINO chip ID (Rev/ID: 0x%02lx)\n",
+                       rev_id);
+                vino_module_cleanup(vino_init_stage);
+                return -ENODEV;
         }
-        printk(KERN_INFO "VINO Rev: 0x%02lx\n", VINO_REV_NUM(rev));
 
-        Vino = (struct vino_video *)
-                kmalloc(sizeof(struct vino_video), GFP_KERNEL);
-        if (!Vino) {
-                ret = -ENOMEM;
-                goto out_unmap;
+        printk(KERN_INFO "VINO with chip ID %ld, revision %ld found\n",
+               VINO_ID_VALUE(rev_id), VINO_REV_NUM(rev_id));
+
+        return 0;
+}
+
+static int vino_init(void)
+{
+        dma_addr_t dma_dummy_address;
+        int i;
+
+        vino_drvdata = (struct vino_settings *)
+                kmalloc(sizeof(struct vino_settings), GFP_KERNEL);
+        if (!vino_drvdata) {
+                vino_module_cleanup(vino_init_stage);
+                return -ENOMEM;
         }
+        memset(vino_drvdata, 0, sizeof(struct vino_settings));
+        vino_init_stage++;
 
-        Vino->dummy_page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
-        if (!Vino->dummy_page) {
-                ret = -ENOMEM;
-                goto out_free_vino;
+        /* create a dummy dma descriptor */
+        vino_drvdata->dummy_page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
+        if (!vino_drvdata->dummy_page) {
+                vino_module_cleanup(vino_init_stage);
+                return -ENOMEM;
         }
-        for (i = 0; i < 4; i++)
-                Vino->dummy_buf[i] = PHYSADDR(Vino->dummy_page);
+        vino_init_stage++;
+
+        // TODO: use page_count in dummy_desc_table
+
+        vino_drvdata->dummy_desc_table.dma_cpu =
+                dma_alloc_coherent(NULL,
+                VINO_DUMMY_DESC_COUNT * sizeof(dma_addr_t),
+                &vino_drvdata->dummy_desc_table.dma,
+                GFP_KERNEL | GFP_DMA);
+        if (!vino_drvdata->dummy_desc_table.dma_cpu) {
+                vino_module_cleanup(vino_init_stage);
+                return -ENOMEM;
+        }
+        vino_init_stage++;
+
+        dma_dummy_address = dma_map_single(NULL,
+                                           (void *)vino_drvdata->dummy_page,
+                                        PAGE_SIZE, DMA_FROM_DEVICE);
+        for (i = 0; i < VINO_DUMMY_DESC_COUNT; i++) {
+                vino_drvdata->dummy_desc_table.dma_cpu[i] = dma_dummy_address;
+        }
+
+        /* initialize VINO */
 
         vino->control = 0;
-        /* prevent VINO from throwing spurious interrupts */
-        vino->a.next_4_desc = PHYSADDR(Vino->dummy_buf);
-        vino->b.next_4_desc = PHYSADDR(Vino->dummy_buf);
-        udelay(5);
+        vino->a.next_4_desc = vino_drvdata->dummy_desc_table.dma;
+        vino->b.next_4_desc = vino_drvdata->dummy_desc_table.dma;
+        udelay(VINO_DESC_FETCH_DELAY);
+
         vino->intr_status = 0;
-        /* set threshold level */
-        vino->a.fifo_thres = threshold_a;
-        vino->b.fifo_thres = threshold_b;
 
-        init_MUTEX(&Vino->input_lock);
+        vino->a.fifo_thres = VINO_FIFO_THRESHOLD_DEFAULT;
+        vino->b.fifo_thres = VINO_FIFO_THRESHOLD_DEFAULT;
+
+        return 0;
+}
+
+static int vino_init_channel_settings(struct vino_channel_settings *vcs,
+                                 unsigned int channel, const char *name)
+{
+        vcs->channel = channel;
+        vcs->input = VINO_INPUT_NONE;
+        vcs->alpha = 0;
+        vcs->users = 0;
+        vcs->data_format = VINO_DATA_FMT_GREY;
+        vcs->data_norm = VINO_DATA_NORM_NTSC;
+        vcs->decimation = 1;
+        vino_set_default_clipping(vcs);
+        vino_set_default_framerate(vcs);
+
+        vcs->capturing = 0;
+
+        init_MUTEX(&vcs->sem);
+        spin_lock_init(&vcs->capture_lock);
+
+        init_MUTEX(&vcs->fb_queue.queue_sem);
+        spin_lock_init(&vcs->fb_queue.queue_lock);
+        init_waitqueue_head(&vcs->fb_queue.frame_wait_queue);
+
+        vcs->v4l_device = video_device_alloc();
+        if (!vcs->v4l_device) {
+                vino_module_cleanup(vino_init_stage);
+                return -ENOMEM;
+        }
+        vino_init_stage++;
+
+        memcpy(vcs->v4l_device, &v4l_device_template,
+               sizeof(struct video_device));
+        strcpy(vcs->v4l_device->name, name);
+        vcs->v4l_device->release = video_device_release;
+
+        video_set_drvdata(vcs->v4l_device, vcs);
+
+        return 0;
+}
+
+static int __init vino_module_init(void)
+{
+        int ret;
+
+        printk(KERN_INFO "SGI VINO driver version %s\n",
+               VINO_MODULE_VERSION);
+
+        ret = vino_probe();
+        if (ret)
+                return ret;
+
+        ret = vino_init();
+        if (ret)
+                return ret;
+
+        /* initialize data structures */
 
-        if (request_irq(SGI_VINO_IRQ, vino_interrupt, 0, vinostr, NULL)) {
-                printk(KERN_ERR "VINO: irq%02d registration failed\n",
+        spin_lock_init(&vino_drvdata->vino_lock);
+        spin_lock_init(&vino_drvdata->input_lock);
+
+        ret = vino_init_channel_settings(&vino_drvdata->a, VINO_CHANNEL_A,
+                                    vino_v4l_device_name_a);
+        if (ret)
+                return ret;
+
+        ret = vino_init_channel_settings(&vino_drvdata->b, VINO_CHANNEL_B,
+                                    vino_v4l_device_name_b);
+        if (ret)
+                return ret;
+
+        /* initialize hardware and register V4L devices */
+
+        ret = request_irq(SGI_VINO_IRQ, vino_interrupt, 0,
+                vino_driver_description, NULL);
+        if (ret) {
+                printk(KERN_ERR "VINO: requesting IRQ %02d failed\n",
                        SGI_VINO_IRQ);
-                ret = -EAGAIN;
-                goto out_free_page;
+                vino_module_cleanup(vino_init_stage);
+                return -EAGAIN;
         }
+        vino_init_stage++;
 
         ret = vino_i2c_add_bus();
         if (ret) {
-                printk(KERN_ERR "VINO: I2C bus registration failed\n");
-                goto out_free_irq;
+                printk(KERN_ERR "VINO I2C bus registration failed\n");
+                vino_module_cleanup(vino_init_stage);
+                return ret;
         }
+        vino_init_stage++;
 
-        if (video_register_device(&Vino->chA.vdev, VFL_TYPE_GRABBER, -1) < 0) {
-                printk("%s, chnl %d: device registration failed.\n",
-                        Vino->chA.vdev.name, Vino->chA.chan);
-                ret = -EINVAL;
-                goto out_i2c_del_bus;
+        ret = video_register_device(vino_drvdata->a.v4l_device,
+                                    VFL_TYPE_GRABBER, -1);
+        if (ret < 0) {
+                printk(KERN_ERR "VINO channel A Video4Linux-device "
+                       "registration failed\n");
+                vino_module_cleanup(vino_init_stage);
+                return -EINVAL;
         }
-        if (video_register_device(&Vino->chB.vdev, VFL_TYPE_GRABBER, -1) < 0) {
-                printk("%s, chnl %d: device registration failed.\n",
-                        Vino->chB.vdev.name, Vino->chB.chan);
-                ret = -EINVAL;
-                goto out_unregister_vdev;
+        vino_init_stage++;
+
+        ret = video_register_device(vino_drvdata->b.v4l_device,
+                                    VFL_TYPE_GRABBER, -1);
+        if (ret < 0) {
+                printk(KERN_ERR "VINO channel B Video4Linux-device "
+                       "registration failed\n");
+                vino_module_cleanup(vino_init_stage);
+                return -EINVAL;
         }
+        vino_init_stage++;
 
-        return 0;
+#if defined(CONFIG_KMOD) && defined(MODULE)
+        request_module("saa7191");
+        request_module("indycam");
+#endif
 
-out_unregister_vdev:
-        video_unregister_device(&Vino->chA.vdev);
-out_i2c_del_bus:
-        vino_i2c_del_bus();
-out_free_irq:
-        free_irq(SGI_VINO_IRQ, NULL);
-out_free_page:
-        free_page(Vino->dummy_page);
-out_free_vino:
-        kfree(Vino);
-out_unmap:
-        iounmap(vino);
+        dprintk("init complete!\n");
 
-        return ret;
+        return 0;
 }
 
-static void __exit vino_exit(void)
+static void __exit vino_module_exit(void)
 {
-        video_unregister_device(&Vino->chA.vdev);
-        video_unregister_device(&Vino->chB.vdev);
-        vino_i2c_del_bus();
-        free_irq(SGI_VINO_IRQ, NULL);
-        free_page(Vino->dummy_page);
-        kfree(Vino);
-        iounmap(vino);
+        dprintk("exiting, stage = %d ...\n", vino_init_stage);
+        vino_module_cleanup(vino_init_stage);
+        dprintk("cleanup complete, exit!\n");
 }
 
-module_init(vino_init);
-module_exit(vino_exit);
-
-MODULE_DESCRIPTION("Video4Linux driver for SGI Indy VINO (IndyCam)");
-MODULE_LICENSE("GPL");
+module_init(vino_module_init);
+module_exit(vino_module_exit);
diff --git a/drivers/media/video/vino.h b/drivers/media/video/vino.h
index d2fce472f35a..de2d615ae7c9 100644
--- a/drivers/media/video/vino.h
+++ b/drivers/media/video/vino.h
@@ -1,13 +1,19 @@
 /*
+ * Driver for the VINO (Video In No Out) system found in SGI Indys.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
  * Copyright (C) 1999 Ulf Karlsson <ulfc@bun.falkenberg.se>
  * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
  */
 
-#ifndef VINO_H
-#define VINO_H
+#ifndef _VINO_H_
+#define _VINO_H_
 
 #define VINO_BASE       0x00080000      /* Vino is in the EISA address space,
                                          * but it is not an EISA bus card */
+#define VINO_PAGE_SIZE  4096
 
 struct sgi_vino_channel {
         u32 _pad_alpha;
@@ -21,8 +27,9 @@ struct sgi_vino_channel {
         u32 _pad_clip_end;
         volatile u32 clip_end;
 
+#define VINO_FRAMERT_FULL       0xfff
 #define VINO_FRAMERT_PAL        (1<<0)                  /* 0=NTSC 1=PAL */
-#define VINO_FRAMERT_RT(x)      (((x) & 0x1fff) << 1)   /* bits 1:12 */
+#define VINO_FRAMERT_RT(x)      (((x) & 0xfff) << 1)    /* bits 1:12 */
         u32 _pad_frame_rate;
         volatile u32 frame_rate;
 
@@ -67,18 +74,18 @@ struct sgi_vino {
         volatile u32 rev_id;
 
 #define VINO_CTRL_LITTLE_ENDIAN         (1<<0)
-#define VINO_CTRL_A_FIELD_TRANS_INT     (1<<1)  /* Field transferred int */
-#define VINO_CTRL_A_FIFO_OF_INT         (1<<2)  /* FIFO overflow int */
-#define VINO_CTRL_A_END_DESC_TBL_INT    (1<<3)  /* End of desc table int */
-#define VINO_CTRL_A_INT                 (VINO_CTRL_A_FIELD_TRANS_INT | \
-                                         VINO_CTRL_A_FIFO_OF_INT | \
-                                         VINO_CTRL_A_END_DESC_TBL_INT)
-#define VINO_CTRL_B_FIELD_TRANS_INT     (1<<4)  /* Field transferred int */
-#define VINO_CTRL_B_FIFO_OF_INT         (1<<5)  /* FIFO overflow int */
-#define VINO_CTRL_B_END_DESC_TBL_INT    (1<<6)  /* End of desc table int */
-#define VINO_CTRL_B_INT                 (VINO_CTRL_B_FIELD_TRANS_INT | \
-                                         VINO_CTRL_B_FIFO_OF_INT | \
-                                         VINO_CTRL_B_END_DESC_TBL_INT)
+#define VINO_CTRL_A_EOF_INT             (1<<1)  /* Field transferred int */
+#define VINO_CTRL_A_FIFO_INT            (1<<2)  /* FIFO overflow int */
+#define VINO_CTRL_A_EOD_INT             (1<<3)  /* End of desc table int */
+#define VINO_CTRL_A_INT                 (VINO_CTRL_A_EOF_INT | \
+                                         VINO_CTRL_A_FIFO_INT | \
+                                         VINO_CTRL_A_EOD_INT)
+#define VINO_CTRL_B_EOF_INT             (1<<4)  /* Field transferred int */
+#define VINO_CTRL_B_FIFO_INT            (1<<5)  /* FIFO overflow int */
+#define VINO_CTRL_B_EOD_INT             (1<<6)  /* End of desc table int */
+#define VINO_CTRL_B_INT                 (VINO_CTRL_B_EOF_INT | \
+                                         VINO_CTRL_B_FIFO_INT | \
+                                         VINO_CTRL_B_EOD_INT)
 #define VINO_CTRL_A_DMA_ENBL            (1<<7)
 #define VINO_CTRL_A_INTERLEAVE_ENBL     (1<<8)
 #define VINO_CTRL_A_SYNC_ENBL           (1<<9)
@@ -104,18 +111,18 @@ struct sgi_vino {
         u32 _pad_control;
         volatile u32 control;
 
-#define VINO_INTSTAT_A_FIELD_TRANS      (1<<0)  /* Field transferred int */
-#define VINO_INTSTAT_A_FIFO_OF          (1<<1)  /* FIFO overflow int */
-#define VINO_INTSTAT_A_END_DESC_TBL     (1<<2)  /* End of desc table int */
-#define VINO_INTSTAT_A                  (VINO_INTSTAT_A_FIELD_TRANS | \
-                                         VINO_INTSTAT_A_FIFO_OF | \
-                                         VINO_INTSTAT_A_END_DESC_TBL)
-#define VINO_INTSTAT_B_FIELD_TRANS      (1<<3)  /* Field transferred int */
-#define VINO_INTSTAT_B_FIFO_OF          (1<<4)  /* FIFO overflow int */
-#define VINO_INTSTAT_B_END_DESC_TBL     (1<<5)  /* End of desc table int */
-#define VINO_INTSTAT_B                  (VINO_INTSTAT_B_FIELD_TRANS | \
-                                         VINO_INTSTAT_B_FIFO_OF | \
-                                         VINO_INTSTAT_B_END_DESC_TBL)
+#define VINO_INTSTAT_A_EOF              (1<<0)  /* Field transferred int */
+#define VINO_INTSTAT_A_FIFO             (1<<1)  /* FIFO overflow int */
+#define VINO_INTSTAT_A_EOD              (1<<2)  /* End of desc table int */
+#define VINO_INTSTAT_A                  (VINO_INTSTAT_A_EOF | \
+                                         VINO_INTSTAT_A_FIFO | \
+                                         VINO_INTSTAT_A_EOD)
+#define VINO_INTSTAT_B_EOF              (1<<3)  /* Field transferred int */
+#define VINO_INTSTAT_B_FIFO             (1<<4)  /* FIFO overflow int */
+#define VINO_INTSTAT_B_EOD              (1<<5)  /* End of desc table int */
+#define VINO_INTSTAT_B                  (VINO_INTSTAT_B_EOF | \
+                                         VINO_INTSTAT_B_FIFO | \
+                                         VINO_INTSTAT_B_EOD)
         u32 _pad_intr_status;
         volatile u32 intr_status;
 
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index dea6589d1533..7fc692a8f5b0 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -6,7 +6,7 @@ menu "Misc devices"
 
 config IBM_ASM
         tristate "Device driver for IBM RSA service processor"
-        depends on X86 && PCI && EXPERIMENTAL && BROKEN
+        depends on X86 && PCI && EXPERIMENTAL
         ---help---
           This option enables device driver support for in-band access to the
           IBM RSA (Condor) service processor in eServer xSeries systems.
diff --git a/drivers/misc/ibmasm/uart.c b/drivers/misc/ibmasm/uart.c
index 914804512dba..7e98434cfa37 100644
--- a/drivers/misc/ibmasm/uart.c
+++ b/drivers/misc/ibmasm/uart.c
@@ -25,15 +25,15 @@
 #include <linux/termios.h>
 #include <linux/tty.h>
 #include <linux/serial_core.h>
-#include <linux/serial.h>
 #include <linux/serial_reg.h>
+#include <linux/serial_8250.h>
 #include "ibmasm.h"
 #include "lowlevel.h"
 
 
 void ibmasm_register_uart(struct service_processor *sp)
 {
-        struct serial_struct serial;
+        struct uart_port uport;
         void __iomem *iomem_base;
 
         iomem_base = sp->base_address + SCOUT_COM_B_BASE;
@@ -47,14 +47,14 @@ void ibmasm_register_uart(struct service_processor *sp)
                 return;
         }
 
-        memset(&serial, 0, sizeof(serial));
-        serial.irq              = sp->irq;
-        serial.baud_base        = 3686400 / 16;
-        serial.flags            = UPF_AUTOPROBE | UPF_SHARE_IRQ;
-        serial.io_type          = UPIO_MEM;
-        serial.iomem_base       = iomem_base;
+        memset(&uport, 0, sizeof(struct uart_port));
+        uport.irq       = sp->irq;
+        uport.uartclk   = 3686400;
+        uport.flags     = UPF_AUTOPROBE | UPF_SHARE_IRQ;
+        uport.iotype    = UPIO_MEM;
+        uport.membase   = iomem_base;
 
-        sp->serial_line = register_serial(&serial);
+        sp->serial_line = serial8250_register_port(&uport);
         if (sp->serial_line < 0) {
                 dev_err(sp->dev, "Failed to register serial port\n");
                 return;
@@ -68,5 +68,5 @@ void ibmasm_unregister_uart(struct service_processor *sp)
                 return;
 
         disable_uart_interrupts(sp->base_address);
-        unregister_serial(sp->serial_line);
+        serial8250_unregister_port(sp->serial_line);
 }
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index 0a8165974ba7..0a117c61cd18 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -2,6 +2,8 @@
  *  linux/drivers/mmc/mmc.c
  *
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
+ *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
+ *  SD support Copyright (C) 2005 Pierre Ossman, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -16,6 +18,8 @@
 #include <linux/delay.h>
 #include <linux/pagemap.h>
 #include <linux/err.h>
+#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -172,7 +176,81 @@ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries
 
 EXPORT_SYMBOL(mmc_wait_for_cmd);
 
+/**
+ *      mmc_wait_for_app_cmd - start an application command and wait for
+                               completion
+ *      @host: MMC host to start command
+ *      @rca: RCA to send MMC_APP_CMD to
+ *      @cmd: MMC command to start
+ *      @retries: maximum number of retries
+ *
+ *      Sends a MMC_APP_CMD, checks the card response, sends the command
+ *      in the parameter and waits for it to complete. Return any error
+ *      that occurred while the command was executing.  Do not attempt to
+ *      parse the response.
+ */
+int mmc_wait_for_app_cmd(struct mmc_host *host, unsigned int rca,
+        struct mmc_command *cmd, int retries)
+{
+        struct mmc_request mrq;
+        struct mmc_command appcmd;
+
+        int i, err;
+
+        BUG_ON(host->card_busy == NULL);
+        BUG_ON(retries < 0);
+
+        err = MMC_ERR_INVALID;
+
+        /*
+         * We have to resend MMC_APP_CMD for each attempt so
+         * we cannot use the retries field in mmc_command.
+         */
+        for (i = 0;i <= retries;i++) {
+                memset(&mrq, 0, sizeof(struct mmc_request));
+
+                appcmd.opcode = MMC_APP_CMD;
+                appcmd.arg = rca << 16;
+                appcmd.flags = MMC_RSP_R1;
+                appcmd.retries = 0;
+                memset(appcmd.resp, 0, sizeof(appcmd.resp));
+                appcmd.data = NULL;
+
+                mrq.cmd = &appcmd;
+                appcmd.data = NULL;
+
+                mmc_wait_for_req(host, &mrq);
+
+                if (appcmd.error) {
+                        err = appcmd.error;
+                        continue;
+                }
+
+                /* Check that card supported application commands */
+                if (!(appcmd.resp[0] & R1_APP_CMD))
+                        return MMC_ERR_FAILED;
+
+                memset(&mrq, 0, sizeof(struct mmc_request));
+
+                memset(cmd->resp, 0, sizeof(cmd->resp));
+                cmd->retries = 0;
+
+                mrq.cmd = cmd;
+                cmd->data = NULL;
 
+                mmc_wait_for_req(host, &mrq);
+
+                err = cmd->error;
+                if (cmd->error == MMC_ERR_NONE)
+                        break;
+        }
+
+        return err;
+}
+
+EXPORT_SYMBOL(mmc_wait_for_app_cmd);
+
+static int mmc_select_card(struct mmc_host *host, struct mmc_card *card);
 
 /**
  *      __mmc_claim_host - exclusively claim a host
@@ -206,16 +284,10 @@ int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card)
         spin_unlock_irqrestore(&host->lock, flags);
         remove_wait_queue(&host->wq, &wait);
 
-        if (card != (void *)-1 && host->card_selected != card) {
-                struct mmc_command cmd;
-
-                host->card_selected = card;
-
-                cmd.opcode = MMC_SELECT_CARD;
-                cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R1;
-
-                err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+        if (card != (void *)-1) {
+                err = mmc_select_card(host, card);
+                if (err != MMC_ERR_NONE)
+                        return err;
         }
 
         return err;
@@ -245,6 +317,63 @@ void mmc_release_host(struct mmc_host *host)
 
 EXPORT_SYMBOL(mmc_release_host);
 
+static int mmc_select_card(struct mmc_host *host, struct mmc_card *card)
+{
+        int err;
+        struct mmc_command cmd;
+
+        BUG_ON(host->card_busy == NULL);
+
+        if (host->card_selected == card)
+                return MMC_ERR_NONE;
+
+        host->card_selected = card;
+
+        cmd.opcode = MMC_SELECT_CARD;
+        cmd.arg = card->rca << 16;
+        cmd.flags = MMC_RSP_R1;
+
+        err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+        if (err != MMC_ERR_NONE)
+                return err;
+
+        /*
+         * Default bus width is 1 bit.
+         */
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
+
+        /*
+         * We can only change the bus width of the selected
+         * card so therefore we have to put the handling
+         * here.
+         */
+        if (host->caps & MMC_CAP_4_BIT_DATA) {
+                /*
+                 * The card is in 1 bit mode by default so
+                 * we only need to change if it supports the
+                 * wider version.
+                 */
+                if (mmc_card_sd(card) &&
+                        (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
+                        struct mmc_command cmd;
+                        cmd.opcode = SD_APP_SET_BUS_WIDTH;
+                        cmd.arg = SD_BUS_WIDTH_4;
+                        cmd.flags = MMC_RSP_R1;
+
+                        err = mmc_wait_for_app_cmd(host, card->rca, &cmd,
+                                CMD_RETRIES);
+                        if (err != MMC_ERR_NONE)
+                                return err;
+
+                        host->ios.bus_width = MMC_BUS_WIDTH_4;
+                }
+        }
+
+        host->ops->set_ios(host, &host->ios);
+
+        return MMC_ERR_NONE;
+}
+
 /*
  * Ensure that no card is selected.
  */
@@ -322,48 +451,69 @@ static void mmc_decode_cid(struct mmc_card *card)
 
         memset(&card->cid, 0, sizeof(struct mmc_cid));
 
-        /*
-         * The selection of the format here is guesswork based upon
-         * information people have sent to date.
-         */
-        switch (card->csd.mmca_vsn) {
-        case 0: /* MMC v1.? */
-        case 1: /* MMC v1.4 */
-                card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
-                card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
-                card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
-                card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
-                card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
-                card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
-                card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
-                card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
-                card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
-                card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
-                card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
-                card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
-                card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
-                break;
-
-        case 2: /* MMC v2.x ? */
-        case 3: /* MMC v3.x ? */
-                card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
-                card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
-                card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
-                card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
-                card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
-                card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
-                card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
-                card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
-                card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
-                card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
-                card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
-                break;
-
-        default:
-                printk("%s: card has unknown MMCA version %d\n",
-                        mmc_hostname(card->host), card->csd.mmca_vsn);
-                mmc_card_set_bad(card);
-                break;
+        if (mmc_card_sd(card)) {
+                /*
+                 * SD doesn't currently have a version field so we will
+                 * have to assume we can parse this.
+                 */
+                card->cid.manfid                = UNSTUFF_BITS(resp, 120, 8);
+                card->cid.oemid                 = UNSTUFF_BITS(resp, 104, 16);
+                card->cid.prod_name[0]          = UNSTUFF_BITS(resp, 96, 8);
+                card->cid.prod_name[1]          = UNSTUFF_BITS(resp, 88, 8);
+                card->cid.prod_name[2]          = UNSTUFF_BITS(resp, 80, 8);
+                card->cid.prod_name[3]          = UNSTUFF_BITS(resp, 72, 8);
+                card->cid.prod_name[4]          = UNSTUFF_BITS(resp, 64, 8);
+                card->cid.hwrev                 = UNSTUFF_BITS(resp, 60, 4);
+                card->cid.fwrev                 = UNSTUFF_BITS(resp, 56, 4);
+                card->cid.serial                = UNSTUFF_BITS(resp, 24, 32);
+                card->cid.year                  = UNSTUFF_BITS(resp, 12, 8);
+                card->cid.month                 = UNSTUFF_BITS(resp, 8, 4);
+
+                card->cid.year += 2000; /* SD cards year offset */
+        } else {
+                /*
+                 * The selection of the format here is based upon published
+                 * specs from sandisk and from what people have reported.
+                 */
+                switch (card->csd.mmca_vsn) {
+                case 0: /* MMC v1.0 - v1.2 */
+                case 1: /* MMC v1.4 */
+                        card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
+                        card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
+                        card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
+                        card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
+                        card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
+                        card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
+                        card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
+                        card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
+                        card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
+                        card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
+                        card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
+                        card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
+                        card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
+                        break;
+
+                case 2: /* MMC v2.0 - v2.2 */
+                case 3: /* MMC v3.1 - v3.3 */
+                        card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
+                        card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
+                        card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
+                        card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
+                        card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
+                        card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
+                        card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
+                        card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
+                        card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
+                        card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
+                        card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
+                        break;
+
+                default:
+                        printk("%s: card has unknown MMCA version %d\n",
+                                mmc_hostname(card->host), card->csd.mmca_vsn);
+                        mmc_card_set_bad(card);
+                        break;
+                }
         }
 }
 
@@ -376,34 +526,86 @@ static void mmc_decode_csd(struct mmc_card *card)
         unsigned int e, m, csd_struct;
         u32 *resp = card->raw_csd;
 
-        /*
-         * We only understand CSD structure v1.1 and v2.
-         * v2 has extra information in bits 15, 11 and 10.
-         */
-        csd_struct = UNSTUFF_BITS(resp, 126, 2);
-        if (csd_struct != 1 && csd_struct != 2) {
-                printk("%s: unrecognised CSD structure version %d\n",
-                        mmc_hostname(card->host), csd_struct);
-                mmc_card_set_bad(card);
-                return;
+        if (mmc_card_sd(card)) {
+                csd_struct = UNSTUFF_BITS(resp, 126, 2);
+                if (csd_struct != 0) {
+                        printk("%s: unrecognised CSD structure version %d\n",
+                                mmc_hostname(card->host), csd_struct);
+                        mmc_card_set_bad(card);
+                        return;
+                }
+
+                m = UNSTUFF_BITS(resp, 115, 4);
+                e = UNSTUFF_BITS(resp, 112, 3);
+                csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
+                csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+
+                m = UNSTUFF_BITS(resp, 99, 4);
+                e = UNSTUFF_BITS(resp, 96, 3);
+                csd->max_dtr      = tran_exp[e] * tran_mant[m];
+                csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+
+                e = UNSTUFF_BITS(resp, 47, 3);
+                m = UNSTUFF_BITS(resp, 62, 12);
+                csd->capacity     = (1 + m) << (e + 2);
+
+                csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
+        } else {
+                /*
+                 * We only understand CSD structure v1.1 and v1.2.
+                 * v1.2 has extra information in bits 15, 11 and 10.
+                 */
+                csd_struct = UNSTUFF_BITS(resp, 126, 2);
+                if (csd_struct != 1 && csd_struct != 2) {
+                        printk("%s: unrecognised CSD structure version %d\n",
+                                mmc_hostname(card->host), csd_struct);
+                        mmc_card_set_bad(card);
+                        return;
+                }
+
+                csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
+                m = UNSTUFF_BITS(resp, 115, 4);
+                e = UNSTUFF_BITS(resp, 112, 3);
+                csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
+                csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+
+                m = UNSTUFF_BITS(resp, 99, 4);
+                e = UNSTUFF_BITS(resp, 96, 3);
+                csd->max_dtr      = tran_exp[e] * tran_mant[m];
+                csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+
+                e = UNSTUFF_BITS(resp, 47, 3);
+                m = UNSTUFF_BITS(resp, 62, 12);
+                csd->capacity     = (1 + m) << (e + 2);
+
+                csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
         }
+}
 
-        csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
-        m = UNSTUFF_BITS(resp, 115, 4);
-        e = UNSTUFF_BITS(resp, 112, 3);
-        csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
-        csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+/*
+ * Given a 64-bit response, decode to our card SCR structure.
+ */
+static void mmc_decode_scr(struct mmc_card *card)
+{
+        struct sd_scr *scr = &card->scr;
+        unsigned int scr_struct;
+        u32 resp[4];
+
+        BUG_ON(!mmc_card_sd(card));
 
-        m = UNSTUFF_BITS(resp, 99, 4);
-        e = UNSTUFF_BITS(resp, 96, 3);
-        csd->max_dtr      = tran_exp[e] * tran_mant[m];
-        csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+        resp[3] = card->raw_scr[1];
+        resp[2] = card->raw_scr[0];
 
-        e = UNSTUFF_BITS(resp, 47, 3);
-        m = UNSTUFF_BITS(resp, 62, 12);
-        csd->capacity     = (1 + m) << (e + 2);
+        scr_struct = UNSTUFF_BITS(resp, 60, 4);
+        if (scr_struct != 0) {
+                printk("%s: unrecognised SCR structure version %d\n",
+                        mmc_hostname(card->host), scr_struct);
+                mmc_card_set_bad(card);
+                return;
+        }
 
-        csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
+        scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
+        scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 }
 
 /*
@@ -487,6 +689,7 @@ static void mmc_power_up(struct mmc_host *host)
         host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
         host->ios.chip_select = MMC_CS_DONTCARE;
         host->ios.power_mode = MMC_POWER_UP;
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ops->set_ios(host, &host->ios);
 
         mmc_delay(1);
@@ -505,6 +708,7 @@ static void mmc_power_off(struct mmc_host *host)
         host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
         host->ios.chip_select = MMC_CS_DONTCARE;
         host->ios.power_mode = MMC_POWER_OFF;
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ops->set_ios(host, &host->ios);
 }
 
@@ -536,6 +740,34 @@ static int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
         return err;
 }
 
+static int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
+{
+        struct mmc_command cmd;
+        int i, err = 0;
+
+        cmd.opcode = SD_APP_OP_COND;
+        cmd.arg = ocr;
+        cmd.flags = MMC_RSP_R3;
+
+        for (i = 100; i; i--) {
+                err = mmc_wait_for_app_cmd(host, 0, &cmd, CMD_RETRIES);
+                if (err != MMC_ERR_NONE)
+                        break;
+
+                if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
+                        break;
+
+                err = MMC_ERR_TIMEOUT;
+
+                mmc_delay(10);
+        }
+
+        if (rocr)
+                *rocr = cmd.resp[0];
+
+        return err;
+}
+
 /*
  * Discover cards by requesting their CID.  If this command
  * times out, it is not an error; there are no further cards
@@ -579,13 +811,38 @@ static void mmc_discover_cards(struct mmc_host *host)
 
                 card->state &= ~MMC_STATE_DEAD;
 
-                cmd.opcode = MMC_SET_RELATIVE_ADDR;
-                cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R1;
+                if (host->mode == MMC_MODE_SD) {
+                        mmc_card_set_sd(card);
 
-                err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
-                if (err != MMC_ERR_NONE)
-                        mmc_card_set_dead(card);
+                        cmd.opcode = SD_SEND_RELATIVE_ADDR;
+                        cmd.arg = 0;
+                        cmd.flags = MMC_RSP_R1;
+
+                        err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+                        if (err != MMC_ERR_NONE)
+                                mmc_card_set_dead(card);
+                        else {
+                                card->rca = cmd.resp[0] >> 16;
+
+                                if (!host->ops->get_ro) {
+                                        printk(KERN_WARNING "%s: host does not "
+                                                "support reading read-only "
+                                                "switch. assuming write-enable.\n",
+                                                mmc_hostname(host));
+                                } else {
+                                        if (host->ops->get_ro(host))
+                                                mmc_card_set_readonly(card);
+                                }
+                        }
+                } else {
+                        cmd.opcode = MMC_SET_RELATIVE_ADDR;
+                        cmd.arg = card->rca << 16;
+                        cmd.flags = MMC_RSP_R1;
+
+                        err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+                        if (err != MMC_ERR_NONE)
+                                mmc_card_set_dead(card);
+                }
         }
 }
 
@@ -617,6 +874,79 @@ static void mmc_read_csds(struct mmc_host *host)
         }
 }
 
+static void mmc_read_scrs(struct mmc_host *host)
+{
+        int err;
+        struct mmc_card *card;
+
+        struct mmc_request mrq;
+        struct mmc_command cmd;
+        struct mmc_data data;
+
+        struct scatterlist sg;
+
+        list_for_each_entry(card, &host->cards, node) {
+                if (card->state & (MMC_STATE_DEAD|MMC_STATE_PRESENT))
+                        continue;
+                if (!mmc_card_sd(card))
+                        continue;
+
+                err = mmc_select_card(host, card);
+                if (err != MMC_ERR_NONE) {
+                        mmc_card_set_dead(card);
+                        continue;
+                }
+
+                memset(&cmd, 0, sizeof(struct mmc_command));
+
+                cmd.opcode = MMC_APP_CMD;
+                cmd.arg = card->rca << 16;
+                cmd.flags = MMC_RSP_R1;
+
+                err = mmc_wait_for_cmd(host, &cmd, 0);
+                if ((err != MMC_ERR_NONE) || !(cmd.resp[0] & R1_APP_CMD)) {
+                        mmc_card_set_dead(card);
+                        continue;
+                }
+
+                memset(&cmd, 0, sizeof(struct mmc_command));
+
+                cmd.opcode = SD_APP_SEND_SCR;
+                cmd.arg = 0;
+                cmd.flags = MMC_RSP_R1;
+
+                memset(&data, 0, sizeof(struct mmc_data));
+
+                data.timeout_ns = card->csd.tacc_ns * 10;
+                data.timeout_clks = card->csd.tacc_clks * 10;
+                data.blksz_bits = 3;
+                data.blocks = 1;
+                data.flags = MMC_DATA_READ;
+                data.sg = &sg;
+                data.sg_len = 1;
+
+                memset(&mrq, 0, sizeof(struct mmc_request));
+
+                mrq.cmd = &cmd;
+                mrq.data = &data;
+
+                sg_init_one(&sg, (u8*)card->raw_scr, 8);
+
+                err = mmc_wait_for_req(host, &mrq);
+                if (err != MMC_ERR_NONE) {
+                        mmc_card_set_dead(card);
+                        continue;
+                }
+
+                card->raw_scr[0] = ntohl(card->raw_scr[0]);
+                card->raw_scr[1] = ntohl(card->raw_scr[1]);
+
+                mmc_decode_scr(card);
+        }
+
+        mmc_deselect_cards(host);
+}
+
 static unsigned int mmc_calculate_clock(struct mmc_host *host)
 {
         struct mmc_card *card;
@@ -669,12 +999,24 @@ static void mmc_setup(struct mmc_host *host)
                 int err;
                 u32 ocr;
 
+                host->mode = MMC_MODE_SD;
+
                 mmc_power_up(host);
                 mmc_idle_cards(host);
 
-                err = mmc_send_op_cond(host, 0, &ocr);
-                if (err != MMC_ERR_NONE)
-                        return;
+                err = mmc_send_app_op_cond(host, 0, &ocr);
+
+                /*
+                 * If we fail to detect any SD cards then try
+                 * searching for MMC cards.
+                 */
+                if (err != MMC_ERR_NONE) {
+                        host->mode = MMC_MODE_MMC;
+
+                        err = mmc_send_op_cond(host, 0, &ocr);
+                        if (err != MMC_ERR_NONE)
+                                return;
+                }
 
                 host->ocr = mmc_select_voltage(host, ocr);
 
@@ -714,7 +1056,10 @@ static void mmc_setup(struct mmc_host *host)
          * all get the idea that they should be ready for CMD2.
          * (My SanDisk card seems to need this.)
          */
-        mmc_send_op_cond(host, host->ocr, NULL);
+        if (host->mode == MMC_MODE_SD)
+                mmc_send_app_op_cond(host, host->ocr, NULL);
+        else
+                mmc_send_op_cond(host, host->ocr, NULL);
 
         mmc_discover_cards(host);
 
@@ -725,6 +1070,9 @@ static void mmc_setup(struct mmc_host *host)
         host->ops->set_ios(host, &host->ios);
 
         mmc_read_csds(host);
+
+        if (host->mode == MMC_MODE_SD)
+                mmc_read_scrs(host);
 }
 
 
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index d4eee99c2bf6..fa83f15fdf16 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -95,6 +95,10 @@ static int mmc_blk_open(struct inode *inode, struct file *filp)
                 if (md->usage == 2)
                         check_disk_change(inode->i_bdev);
                 ret = 0;
+
+                if ((filp->f_mode & FMODE_WRITE) &&
+                        mmc_card_readonly(md->queue.card))
+                        ret = -EROFS;
         }
 
         return ret;
@@ -403,9 +407,10 @@ static int mmc_blk_probe(struct mmc_card *card)
         if (err)
                 goto out;
 
-        printk(KERN_INFO "%s: %s %s %dKiB\n",
+        printk(KERN_INFO "%s: %s %s %dKiB %s\n",
                 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
-                (card->csd.capacity << card->csd.read_blkbits) / 1024);
+                (card->csd.capacity << card->csd.read_blkbits) / 1024,
+                mmc_card_readonly(card)?"(ro)":"");
 
         mmc_set_drvdata(card, md);
         add_disk(md->disk);
diff --git a/drivers/mmc/mmc_sysfs.c b/drivers/mmc/mmc_sysfs.c
index ad8949810fc5..3f4a66ca9555 100644
--- a/drivers/mmc/mmc_sysfs.c
+++ b/drivers/mmc/mmc_sysfs.c
@@ -34,6 +34,7 @@ MMC_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
         card->raw_cid[2], card->raw_cid[3]);
 MMC_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
         card->raw_csd[2], card->raw_csd[3]);
+MMC_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 MMC_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 MMC_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 MMC_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
@@ -57,6 +58,8 @@ static struct device_attribute mmc_dev_attrs[] = {
         __ATTR_NULL
 };
 
+static struct device_attribute mmc_dev_attr_scr = MMC_ATTR_RO(scr);
+
 
 static void mmc_release_card(struct device *dev)
 {
@@ -207,10 +210,20 @@ void mmc_init_card(struct mmc_card *card, struct mmc_host *host)
  */
 int mmc_register_card(struct mmc_card *card)
 {
+        int ret;
+
         snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
                  "%s:%04x", mmc_hostname(card->host), card->rca);
 
-        return device_add(&card->dev);
+        ret = device_add(&card->dev);
+        if (ret == 0) {
+                if (mmc_card_sd(card)) {
+                        ret = device_create_file(&card->dev, &mmc_dev_attr_scr);
+                        if (ret)
+                                device_del(&card->dev);
+                }
+        }
+        return ret;
 }
 
 /*
@@ -219,8 +232,12 @@ int mmc_register_card(struct mmc_card *card)
  */
 void mmc_remove_card(struct mmc_card *card)
 {
-        if (mmc_card_present(card))
+        if (mmc_card_present(card)) {
+                if (mmc_card_sd(card))
+                        device_remove_file(&card->dev, &mmc_dev_attr_scr);
+
                 device_del(&card->dev);
+        }
 
         put_device(&card->dev);
 }
diff --git a/drivers/mmc/pxamci.c b/drivers/mmc/pxamci.c
index b78beb1b0159..e99a53b09e32 100644
--- a/drivers/mmc/pxamci.c
+++ b/drivers/mmc/pxamci.c
@@ -362,6 +362,16 @@ static void pxamci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         pxamci_start_cmd(host, mrq->cmd, cmdat);
 }
 
+static int pxamci_get_ro(struct mmc_host *mmc)
+{
+        struct pxamci_host *host = mmc_priv(mmc);
+
+        if (host->pdata && host->pdata->get_ro)
+                return host->pdata->get_ro(mmc->dev);
+        /* Host doesn't support read only detection so assume writeable */
+        return 0;
+}
+
 static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct pxamci_host *host = mmc_priv(mmc);
@@ -401,6 +411,7 @@ static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
 static struct mmc_host_ops pxamci_ops = {
         .request        = pxamci_request,
+        .get_ro         = pxamci_get_ro,
         .set_ios        = pxamci_set_ios,
 };
 
diff --git a/drivers/mmc/wbsd.c b/drivers/mmc/wbsd.c
index 08ae22aed9e8..dec01d38c782 100644
--- a/drivers/mmc/wbsd.c
+++ b/drivers/mmc/wbsd.c
@@ -720,11 +720,28 @@ static void wbsd_prepare_data(struct wbsd_host* host, struct mmc_data* data)
          * calculate CRC.
          *
          * Space for CRC must be included in the size.
+         * Two bytes are needed for each data line.
          */
-        blksize = (1 << data->blksz_bits) + 2;
+        if (host->bus_width == MMC_BUS_WIDTH_1)
+        {
+                blksize = (1 << data->blksz_bits) + 2;
+
+                wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
+                wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
+        }
+        else if (host->bus_width == MMC_BUS_WIDTH_4)
+        {
+                blksize = (1 << data->blksz_bits) + 2 * 4;
         
-        wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
-        wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
+                wbsd_write_index(host, WBSD_IDX_PBSMSB, ((blksize >> 4) & 0xF0)
+                        | WBSD_DATA_WIDTH);
+                wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
+        }
+        else
+        {
+                data->error = MMC_ERR_INVALID;
+                return;
+        }
 
         /*
          * Clear the FIFO. This is needed even for DMA
@@ -960,9 +977,9 @@ static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
         struct wbsd_host* host = mmc_priv(mmc);
         u8 clk, setup, pwr;
         
-        DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u\n",
-                ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
-                ios->vdd);
+        DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
+             ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
+             ios->vdd, ios->bus_width);
 
         spin_lock_bh(&host->lock);
 
@@ -1010,6 +1027,7 @@ static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
         if (ios->chip_select == MMC_CS_HIGH)
         {
+                BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
                 setup |= WBSD_DAT3_H;
                 host->flags |= WBSD_FIGNORE_DETECT;
         }
@@ -1025,12 +1043,41 @@ static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
         }
         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
         
+        /*
+         * Store bus width for later. Will be used when
+         * setting up the data transfer.
+         */
+        host->bus_width = ios->bus_width;
+
         spin_unlock_bh(&host->lock);
 }
 
+static int wbsd_get_ro(struct mmc_host* mmc)
+{
+        struct wbsd_host* host = mmc_priv(mmc);
+        u8 csr;
+
+        spin_lock_bh(&host->lock);
+
+        csr = inb(host->base + WBSD_CSR);
+        csr |= WBSD_MSLED;
+        outb(csr, host->base + WBSD_CSR);
+
+        mdelay(1);
+
+        csr = inb(host->base + WBSD_CSR);
+        csr &= ~WBSD_MSLED;
+        outb(csr, host->base + WBSD_CSR);
+
+        spin_unlock_bh(&host->lock);
+
+        return csr & WBSD_WRPT;
+}
+
 static struct mmc_host_ops wbsd_ops = {
         .request        = wbsd_request,
         .set_ios        = wbsd_set_ios,
+        .get_ro         = wbsd_get_ro,
 };
 
 /*****************************************************************************\
@@ -1355,6 +1402,7 @@ static int __devinit wbsd_alloc_mmc(struct device* dev)
         mmc->f_min = 375000;
         mmc->f_max = 24000000;
         mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
+        mmc->caps = MMC_CAP_4_BIT_DATA;
         
         spin_lock_init(&host->lock);
         
diff --git a/drivers/mmc/wbsd.h b/drivers/mmc/wbsd.h
index 8af43549f5d5..9005b5241b3c 100644
--- a/drivers/mmc/wbsd.h
+++ b/drivers/mmc/wbsd.h
@@ -106,6 +106,8 @@
 #define WBSD_CLK_16M            0x02
 #define WBSD_CLK_24M            0x03
 
+#define WBSD_DATA_WIDTH         0x01
+
 #define WBSD_DAT3_H             0x08
 #define WBSD_FIFO_RESET         0x04
 #define WBSD_SOFT_RESET         0x02
@@ -164,6 +166,7 @@ struct wbsd_host
         int                     firsterr;       /* See fifo functions */
         
         u8                      clk;            /* Current clock speed */
+        unsigned char           bus_width;      /* Current bus width */
         
         int                     config;         /* Config port */
         u8                      unlock_code;    /* Code to unlock config */
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index eee5115658c8..04e54318bc6a 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -526,6 +526,7 @@ static void nand_wait_ready(struct mtd_info *mtd)
         do {
                 if (this->dev_ready(mtd))
                         return;
+                touch_softlockup_watchdog();
         } while (time_before(jiffies, timeo));  
 }
 
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 07746b95fd83..455ba915ede7 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -973,6 +973,11 @@ static int vortex_suspend (struct pci_dev *pdev, pm_message_t state)
                         netif_device_detach(dev);
                         vortex_down(dev, 1);
                 }
+                pci_save_state(pdev);
+                pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
+                free_irq(dev->irq, dev);
+                pci_disable_device(pdev);
+                pci_set_power_state(pdev, pci_choose_state(pdev, state));
         }
         return 0;
 }
@@ -980,8 +985,19 @@ static int vortex_suspend (struct pci_dev *pdev, pm_message_t state)
 static int vortex_resume (struct pci_dev *pdev)
 {
         struct net_device *dev = pci_get_drvdata(pdev);
+        struct vortex_private *vp = netdev_priv(dev);
 
-        if (dev && dev->priv) {
+        if (dev && vp) {
+                pci_set_power_state(pdev, PCI_D0);
+                pci_restore_state(pdev);
+                pci_enable_device(pdev);
+                pci_set_master(pdev);
+                if (request_irq(dev->irq, vp->full_bus_master_rx ?
+                                &boomerang_interrupt : &vortex_interrupt, SA_SHIRQ, dev->name, dev)) {
+                        printk(KERN_WARNING "%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
+                        pci_disable_device(pdev);
+                        return -EBUSY;
+                }
                 if (netif_running(dev)) {
                         vortex_up(dev);
                         netif_device_attach(dev);
@@ -1873,6 +1889,7 @@ vortex_timer(unsigned long data)
                 {
                         spin_lock_bh(&vp->lock);
                         mii_status = mdio_read(dev, vp->phys[0], 1);
+                        mii_status = mdio_read(dev, vp->phys[0], 1);
                         ok = 1;
                         if (vortex_debug > 2)
                                 printk(KERN_DEBUG "%s: MII transceiver has status %4.4x.\n",
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index ae9e7a579b94..6bb9232514b4 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2058,6 +2058,13 @@ config BNX2
           To compile this driver as a module, choose M here: the module
           will be called bnx2.  This is recommended.
 
+config SPIDER_NET
+        tristate "Spider Gigabit Ethernet driver"
+        depends on PCI && PPC_BPA
+        help
+          This driver supports the Gigabit Ethernet chips present on the
+          Cell Processor-Based Blades from IBM.
+
 config GIANFAR
         tristate "Gianfar Ethernet"
         depends on 85xx || 83xx
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 5baafcd55610..8645c843cf4d 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -54,6 +54,8 @@ obj-$(CONFIG_STNIC) += stnic.o 8390.o
 obj-$(CONFIG_FEALNX) += fealnx.o
 obj-$(CONFIG_TIGON3) += tg3.o
 obj-$(CONFIG_BNX2) += bnx2.o
+spidernet-y += spider_net.o spider_net_ethtool.o sungem_phy.o
+obj-$(CONFIG_SPIDER_NET) += spidernet.o
 obj-$(CONFIG_TC35815) += tc35815.o
 obj-$(CONFIG_SKGE) += skge.o
 obj-$(CONFIG_SK98LIN) += sk98lin/
diff --git a/drivers/net/ac3200.c b/drivers/net/ac3200.c
index 91791ba37769..8a0af5453e21 100644
--- a/drivers/net/ac3200.c
+++ b/drivers/net/ac3200.c
@@ -275,7 +275,7 @@ static int __init ac_probe1(int ioaddr, struct net_device *dev)
         return 0;
 out2:
         if (ei_status.reg0)
-                iounmap((void *)dev->mem_start);
+                iounmap(ei_status.mem);
 out1:
         free_irq(dev->irq, dev);
 out:
diff --git a/drivers/net/arcnet/arcnet.c b/drivers/net/arcnet/arcnet.c
index 4f9f69e22c1b..12ef52c193a3 100644
--- a/drivers/net/arcnet/arcnet.c
+++ b/drivers/net/arcnet/arcnet.c
@@ -597,7 +597,7 @@ static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
         struct ArcProto *proto;
         int txbuf;
         unsigned long flags;
-        int freeskb = 0;
+        int freeskb, retval;
 
         BUGMSG(D_DURING,
                "transmit requested (status=%Xh, txbufs=%d/%d, len=%d, protocol %x)\n",
@@ -615,7 +615,7 @@ static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
         if (skb->len - ARC_HDR_SIZE > XMTU && !proto->continue_tx) {
                 BUGMSG(D_NORMAL, "fixme: packet too large: compensating badly!\n");
                 dev_kfree_skb(skb);
-                return 0;       /* don't try again */
+                return NETDEV_TX_OK;    /* don't try again */
         }
 
         /* We're busy transmitting a packet... */
@@ -623,8 +623,11 @@ static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
 
         spin_lock_irqsave(&lp->lock, flags);
         AINTMASK(0);
-
-        txbuf = get_arcbuf(dev);
+        if(lp->next_tx == -1)
+                txbuf = get_arcbuf(dev);
+        else {
+                txbuf = -1;
+        }
         if (txbuf != -1) {
                 if (proto->prepare_tx(dev, pkt, skb->len, txbuf) &&
                     !proto->ack_tx) {
@@ -638,6 +641,8 @@ static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
                         lp->outgoing.skb = skb;
                         lp->outgoing.pkt = pkt;
 
+                        freeskb = 0;
+
                         if (proto->continue_tx &&
                             proto->continue_tx(dev, txbuf)) {
                           BUGMSG(D_NORMAL,
@@ -645,10 +650,12 @@ static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
                                  "(proto='%c')\n", proto->suffix);
                         }
                 }
-
+                retval = NETDEV_TX_OK;
+                dev->trans_start = jiffies;
                 lp->next_tx = txbuf;
         } else {
-                freeskb = 1;
+                retval = NETDEV_TX_BUSY;
+                freeskb = 0;
         }
 
         BUGMSG(D_DEBUG, "%s: %d: %s, status: %x\n",__FILE__,__LINE__,__FUNCTION__,ASTATUS());
@@ -664,7 +671,7 @@ static int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev)
         if (freeskb) {
                 dev_kfree_skb(skb);
         }
-        return 0;               /* no need to try again */
+        return retval;          /* no need to try again */
 }
 
 
@@ -690,7 +697,6 @@ static int go_tx(struct net_device *dev)
         /* start sending */
         ACOMMAND(TXcmd | (lp->cur_tx << 3));
 
-        dev->trans_start = jiffies;
         lp->stats.tx_packets++;
         lp->lasttrans_dest = lp->lastload_dest;
         lp->lastload_dest = 0;
@@ -917,6 +923,9 @@ irqreturn_t arcnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
                         BUGMSG(D_RECON, "Network reconfiguration detected (status=%Xh)\n",
                                status);
+                        /* MYRECON bit is at bit 7 of diagstatus */
+                        if(diagstatus & 0x80)
+                                BUGMSG(D_RECON,"Put out that recon myself\n");
 
                         /* is the RECON info empty or old? */
                         if (!lp->first_recon || !lp->last_recon ||
diff --git a/drivers/net/atarilance.c b/drivers/net/atarilance.c
index ad011214c7f2..e01b6a78ec63 100644
--- a/drivers/net/atarilance.c
+++ b/drivers/net/atarilance.c
@@ -235,7 +235,7 @@ struct lance_private {
 #define MEM             lp->mem
 #define DREG    IO->data
 #define AREG    IO->addr
-#define REGA(a) ( AREG = (a), DREG )
+#define REGA(a) (*( AREG = (a), &DREG ))
 
 /* Definitions for packet buffer access: */
 #define PKT_BUF_SZ              1544
diff --git a/drivers/net/dm9000.c b/drivers/net/dm9000.c
index 6440a892bb81..e54fc10f6846 100644
--- a/drivers/net/dm9000.c
+++ b/drivers/net/dm9000.c
@@ -1140,7 +1140,7 @@ dm9000_phy_write(struct net_device *dev, int phyaddr_unused, int reg, int value)
 }
 
 static int
-dm9000_drv_suspend(struct device *dev, u32 state, u32 level)
+dm9000_drv_suspend(struct device *dev, pm_message_t state, u32 level)
 {
         struct net_device *ndev = dev_get_drvdata(dev);
 
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 7d93948aec83..d6eefdb71c17 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -1372,7 +1372,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
 
         /* synchronized against open : rtnl_lock() held by caller */
         if (netif_running(dev)) {
-                u8 *base = get_hwbase(dev);
+                u8 __iomem *base = get_hwbase(dev);
                 /*
                  * It seems that the nic preloads valid ring entries into an
                  * internal buffer. The procedure for flushing everything is
@@ -1423,7 +1423,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
 
 static void nv_copy_mac_to_hw(struct net_device *dev)
 {
-        u8 *base = get_hwbase(dev);
+        u8 __iomem *base = get_hwbase(dev);
         u32 mac[2];
 
         mac[0] = (dev->dev_addr[0] << 0) + (dev->dev_addr[1] << 8) +
diff --git a/drivers/net/hamachi.c b/drivers/net/hamachi.c
index d9df1d9a5739..bc9a3bf8d560 100644
--- a/drivers/net/hamachi.c
+++ b/drivers/net/hamachi.c
@@ -204,6 +204,10 @@ KERN_INFO "   Further modifications by Keith Underwood <keithu@parl.clemson.edu>
 
 #define RUN_AT(x) (jiffies + (x))
 
+#ifndef ADDRLEN
+#define ADDRLEN 32
+#endif
+
 /* Condensed bus+endian portability operations. */
 #if ADDRLEN == 64
 #define cpu_to_leXX(addr)       cpu_to_le64(addr)
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index 10125a1dba22..dd89bda1f131 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -4,10 +4,10 @@
  * Description:   Driver for the SMC Infrared Communications Controller
  * Status:        Experimental.
  * Author:        Daniele Peri (peri@csai.unipa.it)
- * Created at:    
- * Modified at:   
- * Modified by:   
- * 
+ * Created at:
+ * Modified at:
+ * Modified by:
+ *
  *     Copyright (c) 2002      Daniele Peri
  *     All Rights Reserved.
  *     Copyright (c) 2002      Jean Tourrilhes
@@ -17,26 +17,26 @@
  *
  *     Copyright (c) 2001      Stefani Seibold
  *     Copyright (c) 1999-2001 Dag Brattli
- *     Copyright (c) 1998-1999 Thomas Davis, 
+ *     Copyright (c) 1998-1999 Thomas Davis,
  *
  *      and irport.c:
  *
  *     Copyright (c) 1997, 1998, 1999-2000 Dag Brattli, All Rights Reserved.
  *
- * 
- *     This program is free software; you can redistribute it and/or 
- *     modify it under the terms of the GNU General Public License as 
- *     published by the Free Software Foundation; either version 2 of 
+ *
+ *     This program is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License as
+ *     published by the Free Software Foundation; either version 2 of
  *     the License, or (at your option) any later version.
- * 
+ *
  *     This program is distributed in the hope that it will be useful,
  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  *     GNU General Public License for more details.
- * 
- *     You should have received a copy of the GNU General Public License 
- *     along with this program; if not, write to the Free Software 
- *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program; if not, write to the Free Software
+ *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  *     MA 02111-1307 USA
  *
  ********************************************************************/
@@ -68,24 +68,42 @@
 #include "smsc-ircc2.h"
 #include "smsc-sio.h"
 
+
+MODULE_AUTHOR("Daniele Peri <peri@csai.unipa.it>");
+MODULE_DESCRIPTION("SMC IrCC SIR/FIR controller driver");
+MODULE_LICENSE("GPL");
+
+static int ircc_dma = 255;
+module_param(ircc_dma, int, 0);
+MODULE_PARM_DESC(ircc_dma, "DMA channel");
+
+static int ircc_irq = 255;
+module_param(ircc_irq, int, 0);
+MODULE_PARM_DESC(ircc_irq, "IRQ line");
+
+static int ircc_fir;
+module_param(ircc_fir, int, 0);
+MODULE_PARM_DESC(ircc_fir, "FIR Base Address");
+
+static int ircc_sir;
+module_param(ircc_sir, int, 0);
+MODULE_PARM_DESC(ircc_sir, "SIR Base Address");
+
+static int ircc_cfg;
+module_param(ircc_cfg, int, 0);
+MODULE_PARM_DESC(ircc_cfg, "Configuration register base address");
+
+static int ircc_transceiver;
+module_param(ircc_transceiver, int, 0);
+MODULE_PARM_DESC(ircc_transceiver, "Transceiver type");
+
 /* Types */
 
 struct smsc_transceiver {
         char *name;
-        void (*set_for_speed)(int fir_base, u32 speed); 
+        void (*set_for_speed)(int fir_base, u32 speed);
         int  (*probe)(int fir_base);
 };
-typedef struct smsc_transceiver smsc_transceiver_t;
-
-#if 0
-struct smc_chip {
-        char *name;
-        u16 flags;
-        u8 devid;
-        u8 rev;
-};
-typedef struct smc_chip smc_chip_t;
-#endif
 
 struct smsc_chip {
         char *name;
@@ -96,20 +114,18 @@ struct smsc_chip {
         u8 devid;
         u8 rev;
 };
-typedef struct smsc_chip smsc_chip_t;
 
 struct smsc_chip_address {
         unsigned int cfg_base;
         unsigned int type;
 };
-typedef struct smsc_chip_address smsc_chip_address_t;
 
 /* Private data for each instance */
 struct smsc_ircc_cb {
         struct net_device *netdev;     /* Yes! we are some kind of netdevice */
         struct net_device_stats stats;
         struct irlap_cb    *irlap; /* The link layer we are binded to */
-        
+
         chipio_t io;               /* IrDA controller information */
         iobuff_t tx_buff;          /* Transmit buffer */
         iobuff_t rx_buff;          /* Receive buffer */
@@ -119,7 +135,7 @@ struct smsc_ircc_cb {
         struct qos_info qos;       /* QoS capabilities for this device */
 
         spinlock_t lock;           /* For serializing operations */
-        
+
         __u32 new_speed;
         __u32 flags;               /* Interface flags */
 
@@ -127,18 +143,20 @@ struct smsc_ircc_cb {
         int tx_len;                /* Number of frames in tx_buff */
 
         int transceiver;
-        struct pm_dev *pmdev;
+        struct platform_device *pldev;
 };
 
 /* Constants */
 
-static const char *driver_name = "smsc-ircc2";
-#define DIM(x)  (sizeof(x)/(sizeof(*(x))))
+#define SMSC_IRCC2_DRIVER_NAME                  "smsc-ircc2"
+
 #define SMSC_IRCC2_C_IRDA_FALLBACK_SPEED        9600
 #define SMSC_IRCC2_C_DEFAULT_TRANSCEIVER        1
-#define SMSC_IRCC2_C_NET_TIMEOUT                        0
+#define SMSC_IRCC2_C_NET_TIMEOUT                0
 #define SMSC_IRCC2_C_SIR_STOP                   0
 
+static const char *driver_name = SMSC_IRCC2_DRIVER_NAME;
+
 /* Prototypes */
 
 static int smsc_ircc_open(unsigned int firbase, unsigned int sirbase, u8 dma, u8 irq);
@@ -147,15 +165,15 @@ static void smsc_ircc_setup_io(struct smsc_ircc_cb *self, unsigned int fir_base,
 static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self);
 static void smsc_ircc_init_chip(struct smsc_ircc_cb *self);
 static int __exit smsc_ircc_close(struct smsc_ircc_cb *self);
-static int  smsc_ircc_dma_receive(struct smsc_ircc_cb *self, int iobase); 
-static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self, int iobase);
+static int  smsc_ircc_dma_receive(struct smsc_ircc_cb *self);
+static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self);
 static void smsc_ircc_sir_receive(struct smsc_ircc_cb *self);
 static int  smsc_ircc_hard_xmit_sir(struct sk_buff *skb, struct net_device *dev);
 static int  smsc_ircc_hard_xmit_fir(struct sk_buff *skb, struct net_device *dev);
-static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int iobase, int bofs);
-static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self, int iobase);
-static void smsc_ircc_change_speed(void *priv, u32 speed);
-static void smsc_ircc_set_sir_speed(void *priv, u32 speed);
+static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int bofs);
+static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self);
+static void smsc_ircc_change_speed(struct smsc_ircc_cb *self, u32 speed);
+static void smsc_ircc_set_sir_speed(struct smsc_ircc_cb *self, u32 speed);
 static irqreturn_t smsc_ircc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 static irqreturn_t smsc_ircc_interrupt_sir(struct net_device *dev);
 static void smsc_ircc_sir_start(struct smsc_ircc_cb *self);
@@ -171,7 +189,6 @@ static int  smsc_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cm
 static void smsc_ircc_timeout(struct net_device *dev);
 #endif
 static struct net_device_stats *smsc_ircc_net_get_stats(struct net_device *dev);
-static int  smsc_ircc_pmproc(struct pm_dev *dev, pm_request_t rqst, void *data);
 static int smsc_ircc_is_receiving(struct smsc_ircc_cb *self);
 static void smsc_ircc_probe_transceiver(struct smsc_ircc_cb *self);
 static void smsc_ircc_set_transceiver_for_speed(struct smsc_ircc_cb *self, u32 speed);
@@ -179,9 +196,9 @@ static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self);
 
 /* Probing */
 static int __init smsc_ircc_look_for_chips(void);
-static const smsc_chip_t * __init smsc_ircc_probe(unsigned short cfg_base,u8 reg,const smsc_chip_t *chip,char *type);
-static int __init smsc_superio_flat(const smsc_chip_t *chips, unsigned short cfg_base, char *type);
-static int __init smsc_superio_paged(const smsc_chip_t *chips, unsigned short cfg_base, char *type);
+static const struct smsc_chip * __init smsc_ircc_probe(unsigned short cfg_base, u8 reg, const struct smsc_chip *chip, char *type);
+static int __init smsc_superio_flat(const struct smsc_chip *chips, unsigned short cfg_base, char *type);
+static int __init smsc_superio_paged(const struct smsc_chip *chips, unsigned short cfg_base, char *type);
 static int __init smsc_superio_fdc(unsigned short cfg_base);
 static int __init smsc_superio_lpc(unsigned short cfg_base);
 
@@ -196,21 +213,26 @@ static int  smsc_ircc_probe_transceiver_smsc_ircc_atc(int fir_base);
 
 /* Power Management */
 
-static void smsc_ircc_suspend(struct smsc_ircc_cb *self);
-static void smsc_ircc_wakeup(struct smsc_ircc_cb *self);
-static int smsc_ircc_pmproc(struct pm_dev *dev, pm_request_t rqst, void *data);
+static int smsc_ircc_suspend(struct device *dev, pm_message_t state, u32 level);
+static int smsc_ircc_resume(struct device *dev, u32 level);
 
+static struct device_driver smsc_ircc_driver = {
+        .name           = SMSC_IRCC2_DRIVER_NAME,
+        .bus            = &platform_bus_type,
+        .suspend        = smsc_ircc_suspend,
+        .resume         = smsc_ircc_resume,
+};
 
 /* Transceivers for SMSC-ircc */
 
-static smsc_transceiver_t smsc_transceivers[]=
+static struct smsc_transceiver smsc_transceivers[] =
 {
-        { "Toshiba Satellite 1800 (GP data pin select)", smsc_ircc_set_transceiver_toshiba_sat1800, smsc_ircc_probe_transceiver_toshiba_sat1800},
-        { "Fast pin select", smsc_ircc_set_transceiver_smsc_ircc_fast_pin_select, smsc_ircc_probe_transceiver_smsc_ircc_fast_pin_select},
-        { "ATC IRMode", smsc_ircc_set_transceiver_smsc_ircc_atc, smsc_ircc_probe_transceiver_smsc_ircc_atc},
-        { NULL, NULL}
+        { "Toshiba Satellite 1800 (GP data pin select)", smsc_ircc_set_transceiver_toshiba_sat1800, smsc_ircc_probe_transceiver_toshiba_sat1800 },
+        { "Fast pin select", smsc_ircc_set_transceiver_smsc_ircc_fast_pin_select, smsc_ircc_probe_transceiver_smsc_ircc_fast_pin_select },
+        { "ATC IRMode", smsc_ircc_set_transceiver_smsc_ircc_atc, smsc_ircc_probe_transceiver_smsc_ircc_atc },
+        { NULL, NULL }
 };
-#define SMSC_IRCC2_C_NUMBER_OF_TRANSCEIVERS (DIM(smsc_transceivers)-1)
+#define SMSC_IRCC2_C_NUMBER_OF_TRANSCEIVERS (ARRAY_SIZE(smsc_transceivers) - 1)
 
 /*  SMC SuperIO chipsets definitions */
 
@@ -221,7 +243,7 @@ static smsc_transceiver_t smsc_transceivers[]=
 #define FIR     4       /* SuperIO Chip has fast IRDA */
 #define SERx4   8       /* SuperIO Chip supports 115,2 KBaud * 4=460,8 KBaud */
 
-static smsc_chip_t __initdata fdc_chips_flat[]=
+static struct smsc_chip __initdata fdc_chips_flat[] =
 {
         /* Base address 0x3f0 or 0x370 */
         { "37C44",      KEY55_1|NoIRDA,         0x00, 0x00 }, /* This chip cannot be detected */
@@ -235,7 +257,7 @@ static smsc_chip_t __initdata fdc_chips_flat[]=
         { NULL }
 };
 
-static smsc_chip_t __initdata fdc_chips_paged[]=
+static struct smsc_chip __initdata fdc_chips_paged[] =
 {
         /* Base address 0x3f0 or 0x370 */
         { "37B72X",     KEY55_1|SIR|SERx4,      0x4c, 0x00 },
@@ -254,7 +276,7 @@ static smsc_chip_t __initdata fdc_chips_paged[]=
         { NULL }
 };
 
-static smsc_chip_t __initdata lpc_chips_flat[]=
+static struct smsc_chip __initdata lpc_chips_flat[] =
 {
         /* Base address 0x2E or 0x4E */
         { "47N227",     KEY55_1|FIR|SERx4,      0x5a, 0x00 },
@@ -262,7 +284,7 @@ static smsc_chip_t __initdata lpc_chips_flat[]=
         { NULL }
 };
 
-static smsc_chip_t __initdata lpc_chips_paged[]=
+static struct smsc_chip __initdata lpc_chips_paged[] =
 {
         /* Base address 0x2E or 0x4E */
         { "47B27X",     KEY55_1|SIR|SERx4,      0x51, 0x00 },
@@ -281,33 +303,25 @@ static smsc_chip_t __initdata lpc_chips_paged[]=
 #define SMSCSIO_TYPE_FLAT       4
 #define SMSCSIO_TYPE_PAGED      8
 
-static smsc_chip_address_t __initdata possible_addresses[]=
+static struct smsc_chip_address __initdata possible_addresses[] =
 {
-        {0x3f0, SMSCSIO_TYPE_FDC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED},
-        {0x370, SMSCSIO_TYPE_FDC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED},
-        {0xe0, SMSCSIO_TYPE_FDC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED},
-        {0x2e, SMSCSIO_TYPE_LPC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED},
-        {0x4e, SMSCSIO_TYPE_LPC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED},
-        {0,0}
+        { 0x3f0, SMSCSIO_TYPE_FDC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED },
+        { 0x370, SMSCSIO_TYPE_FDC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED },
+        { 0xe0,  SMSCSIO_TYPE_FDC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED },
+        { 0x2e,  SMSCSIO_TYPE_LPC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED },
+        { 0x4e,  SMSCSIO_TYPE_LPC|SMSCSIO_TYPE_FLAT|SMSCSIO_TYPE_PAGED },
+        { 0, 0 }
 };
 
 /* Globals */
 
-static struct smsc_ircc_cb *dev_self[] = { NULL, NULL};
-
-static int ircc_irq=255;
-static int ircc_dma=255;
-static int ircc_fir=0;
-static int ircc_sir=0;
-static int ircc_cfg=0;
-static int ircc_transceiver=0;
-
-static unsigned short   dev_count=0;
+static struct smsc_ircc_cb *dev_self[] = { NULL, NULL };
+static unsigned short dev_count;
 
 static inline void register_bank(int iobase, int bank)
 {
-        outb(((inb(iobase+IRCC_MASTER) & 0xf0) | (bank & 0x07)),
-               iobase+IRCC_MASTER);
+        outb(((inb(iobase + IRCC_MASTER) & 0xf0) | (bank & 0x07)),
+               iobase + IRCC_MASTER);
 }
 
 
@@ -327,34 +341,44 @@ static inline void register_bank(int iobase, int bank)
  */
 static int __init smsc_ircc_init(void)
 {
-        int ret=-ENODEV;
+        int ret;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
-        dev_count=0;
- 
-        if ((ircc_fir>0)&&(ircc_sir>0)) {
+        ret = driver_register(&smsc_ircc_driver);
+        if (ret) {
+                IRDA_ERROR("%s, Can't register driver!\n", driver_name);
+                return ret;
+        }
+
+        dev_count = 0;
+
+        if (ircc_fir > 0 && ircc_sir > 0) {
                 IRDA_MESSAGE(" Overriding FIR address 0x%04x\n", ircc_fir);
                 IRDA_MESSAGE(" Overriding SIR address 0x%04x\n", ircc_sir);
 
-                if (smsc_ircc_open(ircc_fir, ircc_sir, ircc_dma, ircc_irq) == 0)
-                        return 0;
-
-                return -ENODEV;
-        }
+                if (smsc_ircc_open(ircc_fir, ircc_sir, ircc_dma, ircc_irq))
+                        ret = -ENODEV;
+        } else {
+                ret = -ENODEV;
+
+                /* try user provided configuration register base address */
+                if (ircc_cfg > 0) {
+                        IRDA_MESSAGE(" Overriding configuration address "
+                                     "0x%04x\n", ircc_cfg);
+                        if (!smsc_superio_fdc(ircc_cfg))
+                                ret = 0;
+                        if (!smsc_superio_lpc(ircc_cfg))
+                                ret = 0;
+                }
 
-        /* try user provided configuration register base address */
-        if (ircc_cfg>0) {
-                IRDA_MESSAGE(" Overriding configuration address 0x%04x\n",
-                             ircc_cfg);
-                if (!smsc_superio_fdc(ircc_cfg))
-                        ret = 0;
-                if (!smsc_superio_lpc(ircc_cfg))
+                if (smsc_ircc_look_for_chips() > 0)
                         ret = 0;
         }
-        
-        if(smsc_ircc_look_for_chips()>0) ret = 0;
-        
+
+        if (ret)
+                driver_unregister(&smsc_ircc_driver);
+
         return ret;
 }
 
@@ -369,15 +393,15 @@ static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u
         struct smsc_ircc_cb *self;
         struct net_device *dev;
         int err;
-        
+
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
         err = smsc_ircc_present(fir_base, sir_base);
-        if(err) 
+        if (err)
                 goto err_out;
-                
+
         err = -ENOMEM;
-        if (dev_count > DIM(dev_self)) {
+        if (dev_count >= ARRAY_SIZE(dev_self)) {
                 IRDA_WARNING("%s(), too many devices!\n", __FUNCTION__);
                 goto err_out1;
         }
@@ -396,14 +420,14 @@ static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u
         dev->hard_start_xmit = smsc_ircc_hard_xmit_sir;
 #if SMSC_IRCC2_C_NET_TIMEOUT
         dev->tx_timeout      = smsc_ircc_timeout;
-        dev->watchdog_timeo  = HZ*2;  /* Allow enough time for speed change */
+        dev->watchdog_timeo  = HZ * 2;  /* Allow enough time for speed change */
 #endif
         dev->open            = smsc_ircc_net_open;
         dev->stop            = smsc_ircc_net_close;
         dev->do_ioctl        = smsc_ircc_net_ioctl;
         dev->get_stats       = smsc_ircc_net_get_stats;
-        
-        self = dev->priv;
+
+        self = netdev_priv(dev);
         self->netdev = dev;
 
         /* Make ifconfig display some details */
@@ -411,10 +435,10 @@ static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u
         dev->irq = self->io.irq = irq;
 
         /* Need to store self somewhere */
-        dev_self[dev_count++] = self;
+        dev_self[dev_count] = self;
         spin_lock_init(&self->lock);
 
-        self->rx_buff.truesize = SMSC_IRCC2_RX_BUFF_TRUESIZE; 
+        self->rx_buff.truesize = SMSC_IRCC2_RX_BUFF_TRUESIZE;
         self->tx_buff.truesize = SMSC_IRCC2_TX_BUFF_TRUESIZE;
 
         self->rx_buff.head =
@@ -442,33 +466,40 @@ static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u
         self->rx_buff.state = OUTSIDE_FRAME;
         self->tx_buff.data = self->tx_buff.head;
         self->rx_buff.data = self->rx_buff.head;
-           
-        smsc_ircc_setup_io(self, fir_base, sir_base, dma, irq);
 
+        smsc_ircc_setup_io(self, fir_base, sir_base, dma, irq);
         smsc_ircc_setup_qos(self);
-
         smsc_ircc_init_chip(self);
-        
-        if(ircc_transceiver > 0  && 
-           ircc_transceiver < SMSC_IRCC2_C_NUMBER_OF_TRANSCEIVERS)
+
+        if (ircc_transceiver > 0  &&
+            ircc_transceiver < SMSC_IRCC2_C_NUMBER_OF_TRANSCEIVERS)
                 self->transceiver = ircc_transceiver;
         else
                 smsc_ircc_probe_transceiver(self);
 
         err = register_netdev(self->netdev);
-        if(err) {
+        if (err) {
                 IRDA_ERROR("%s, Network device registration failed!\n",
                            driver_name);
                 goto err_out4;
         }
 
-        self->pmdev = pm_register(PM_SYS_DEV, PM_SYS_IRDA, smsc_ircc_pmproc);
-        if (self->pmdev)
-                self->pmdev->data = self;
+        self->pldev = platform_device_register_simple(SMSC_IRCC2_DRIVER_NAME,
+                                                      dev_count, NULL, 0);
+        if (IS_ERR(self->pldev)) {
+                err = PTR_ERR(self->pldev);
+                goto err_out5;
+        }
+        dev_set_drvdata(&self->pldev->dev, self);
 
         IRDA_MESSAGE("IrDA: Registered device %s\n", dev->name);
+        dev_count++;
 
         return 0;
+
+ err_out5:
+        unregister_netdev(self->netdev);
+
  err_out4:
         dma_free_coherent(NULL, self->tx_buff.truesize,
                           self->tx_buff.head, self->tx_buff_dma);
@@ -477,7 +508,7 @@ static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u
                           self->rx_buff.head, self->rx_buff_dma);
  err_out2:
         free_netdev(self->netdev);
-        dev_self[--dev_count] = NULL;
+        dev_self[dev_count] = NULL;
  err_out1:
         release_region(fir_base, SMSC_IRCC2_FIR_CHIP_IO_EXTENT);
         release_region(sir_base, SMSC_IRCC2_SIR_CHIP_IO_EXTENT);
@@ -511,16 +542,16 @@ static int smsc_ircc_present(unsigned int fir_base, unsigned int sir_base)
 
         register_bank(fir_base, 3);
 
-        high    = inb(fir_base+IRCC_ID_HIGH);
-        low     = inb(fir_base+IRCC_ID_LOW);
-        chip    = inb(fir_base+IRCC_CHIP_ID);
-        version = inb(fir_base+IRCC_VERSION);
-        config  = inb(fir_base+IRCC_INTERFACE);
+        high    = inb(fir_base + IRCC_ID_HIGH);
+        low     = inb(fir_base + IRCC_ID_LOW);
+        chip    = inb(fir_base + IRCC_CHIP_ID);
+        version = inb(fir_base + IRCC_VERSION);
+        config  = inb(fir_base + IRCC_INTERFACE);
         dma     = config & IRCC_INTERFACE_DMA_MASK;
         irq     = (config & IRCC_INTERFACE_IRQ_MASK) >> 4;
 
-        if (high != 0x10 || low != 0xb8 || (chip != 0xf1 && chip != 0xf2)) { 
-                IRDA_WARNING("%s(), addr 0x%04x - no device found!\n",
+        if (high != 0x10 || low != 0xb8 || (chip != 0xf1 && chip != 0xf2)) {
+                IRDA_WARNING("%s(), addr 0x%04x - no device found!\n",
                              __FUNCTION__, fir_base);
                 goto out3;
         }
@@ -529,6 +560,7 @@ static int smsc_ircc_present(unsigned int fir_base, unsigned int sir_base)
                      chip & 0x0f, version, fir_base, sir_base, dma, irq);
 
         return 0;
+
  out3:
         release_region(sir_base, SMSC_IRCC2_SIR_CHIP_IO_EXTENT);
  out2:
@@ -543,16 +575,16 @@ static int smsc_ircc_present(unsigned int fir_base, unsigned int sir_base)
  *    Setup I/O
  *
  */
-static void smsc_ircc_setup_io(struct smsc_ircc_cb *self, 
-                               unsigned int fir_base, unsigned int sir_base, 
+static void smsc_ircc_setup_io(struct smsc_ircc_cb *self,
+                               unsigned int fir_base, unsigned int sir_base,
                                u8 dma, u8 irq)
 {
         unsigned char config, chip_dma, chip_irq;
 
         register_bank(fir_base, 3);
-        config  = inb(fir_base+IRCC_INTERFACE);
-        chip_dma     = config & IRCC_INTERFACE_DMA_MASK;
-        chip_irq     = (config & IRCC_INTERFACE_IRQ_MASK) >> 4;
+        config = inb(fir_base + IRCC_INTERFACE);
+        chip_dma = config & IRCC_INTERFACE_DMA_MASK;
+        chip_irq = (config & IRCC_INTERFACE_IRQ_MASK) >> 4;
 
         self->io.fir_base  = fir_base;
         self->io.sir_base  = sir_base;
@@ -566,17 +598,15 @@ static void smsc_ircc_setup_io(struct smsc_ircc_cb *self,
                         IRDA_MESSAGE("%s, Overriding IRQ - chip says %d, using %d\n",
                                      driver_name, chip_irq, irq);
                 self->io.irq = irq;
-        }
-        else
+        } else
                 self->io.irq = chip_irq;
-        
+
         if (dma < 255) {
                 if (dma != chip_dma)
                         IRDA_MESSAGE("%s, Overriding DMA - chip says %d, using %d\n",
                                      driver_name, chip_dma, dma);
                 self->io.dma = dma;
-        }
-        else
+        } else
                 self->io.dma = chip_dma;
 
 }
@@ -591,7 +621,7 @@ static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self)
 {
         /* Initialize QoS for this device */
         irda_init_max_qos_capabilies(&self->qos);
-        
+
         self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
                 IR_115200|IR_576000|IR_1152000|(IR_4000000 << 8);
 
@@ -608,43 +638,43 @@ static void smsc_ircc_setup_qos(struct smsc_ircc_cb *self)
  */
 static void smsc_ircc_init_chip(struct smsc_ircc_cb *self)
 {
-        int iobase, ir_mode, ctrl, fast; 
-        
-        IRDA_ASSERT( self != NULL, return; );
-        iobase = self->io.fir_base;
+        int iobase, ir_mode, ctrl, fast;
+
+        IRDA_ASSERT(self != NULL, return;);
 
+        iobase = self->io.fir_base;
         ir_mode = IRCC_CFGA_IRDA_SIR_A;
         ctrl = 0;
         fast = 0;
 
         register_bank(iobase, 0);
-        outb(IRCC_MASTER_RESET, iobase+IRCC_MASTER);
-        outb(0x00, iobase+IRCC_MASTER);
+        outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
+        outb(0x00, iobase + IRCC_MASTER);
 
         register_bank(iobase, 1);
-        outb(((inb(iobase+IRCC_SCE_CFGA) & 0x87) | ir_mode), 
-             iobase+IRCC_SCE_CFGA);
+        outb(((inb(iobase + IRCC_SCE_CFGA) & 0x87) | ir_mode),
+             iobase + IRCC_SCE_CFGA);
 
 #ifdef smsc_669 /* Uses pin 88/89 for Rx/Tx */
-        outb(((inb(iobase+IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_COM), 
-             iobase+IRCC_SCE_CFGB);
-#else   
-        outb(((inb(iobase+IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_IR),
-             iobase+IRCC_SCE_CFGB);
-#endif  
-        (void) inb(iobase+IRCC_FIFO_THRESHOLD);
-        outb(SMSC_IRCC2_FIFO_THRESHOLD, iobase+IRCC_FIFO_THRESHOLD);
-        
+        outb(((inb(iobase + IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_COM),
+             iobase + IRCC_SCE_CFGB);
+#else
+        outb(((inb(iobase + IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_IR),
+             iobase + IRCC_SCE_CFGB);
+#endif
+        (void) inb(iobase + IRCC_FIFO_THRESHOLD);
+        outb(SMSC_IRCC2_FIFO_THRESHOLD, iobase + IRCC_FIFO_THRESHOLD);
+
         register_bank(iobase, 4);
-        outb((inb(iobase+IRCC_CONTROL) & 0x30) | ctrl, iobase+IRCC_CONTROL);
-        
+        outb((inb(iobase + IRCC_CONTROL) & 0x30) | ctrl, iobase + IRCC_CONTROL);
+
         register_bank(iobase, 0);
-        outb(fast, iobase+IRCC_LCR_A);
+        outb(fast, iobase + IRCC_LCR_A);
 
         smsc_ircc_set_sir_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
-        
+
         /* Power on device */
-        outb(0x00, iobase+IRCC_MASTER);
+        outb(0x00, iobase + IRCC_MASTER);
 }
 
 /*
@@ -662,12 +692,12 @@ static int smsc_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd
 
         IRDA_ASSERT(dev != NULL, return -1;);
 
-        self = dev->priv;
+        self = netdev_priv(dev);
 
         IRDA_ASSERT(self != NULL, return -1;);
 
         IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
-        
+
         switch (cmd) {
         case SIOCSBANDWIDTH: /* Set bandwidth */
                 if (!capable(CAP_NET_ADMIN))
@@ -703,14 +733,14 @@ static int smsc_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd
         default:
                 ret = -EOPNOTSUPP;
         }
-        
+
         return ret;
 }
 
 static struct net_device_stats *smsc_ircc_net_get_stats(struct net_device *dev)
 {
-        struct smsc_ircc_cb *self = (struct smsc_ircc_cb *) dev->priv;
-        
+        struct smsc_ircc_cb *self = netdev_priv(dev);
+
         return &self->stats;
 }
 
@@ -724,11 +754,9 @@ static struct net_device_stats *smsc_ircc_net_get_stats(struct net_device *dev)
 
 static void smsc_ircc_timeout(struct net_device *dev)
 {
-        struct smsc_ircc_cb *self;
+        struct smsc_ircc_cb *self = netdev_priv(dev);
         unsigned long flags;
 
-        self = (struct smsc_ircc_cb *) dev->priv;
-        
         IRDA_WARNING("%s: transmit timed out, changing speed to: %d\n",
                      dev->name, self->io.speed);
         spin_lock_irqsave(&self->lock, flags);
@@ -751,26 +779,23 @@ int smsc_ircc_hard_xmit_sir(struct sk_buff *skb, struct net_device *dev)
 {
         struct smsc_ircc_cb *self;
         unsigned long flags;
-        int iobase;
         s32 speed;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
         IRDA_ASSERT(dev != NULL, return 0;);
-        
-        self = (struct smsc_ircc_cb *) dev->priv;
-        IRDA_ASSERT(self != NULL, return 0;);
 
-        iobase = self->io.sir_base;
+        self = netdev_priv(dev);
+        IRDA_ASSERT(self != NULL, return 0;);
 
         netif_stop_queue(dev);
-        
+
         /* Make sure test of self->io.speed & speed change are atomic */
         spin_lock_irqsave(&self->lock, flags);
 
         /* Check if we need to change the speed */
         speed = irda_get_next_speed(skb);
-        if ((speed != self->io.speed) && (speed != -1)) {
+        if (speed != self->io.speed && speed != -1) {
                 /* Check for empty frame */
                 if (!skb->len) {
                         /*
@@ -787,27 +812,26 @@ int smsc_ircc_hard_xmit_sir(struct sk_buff *skb, struct net_device *dev)
                         spin_unlock_irqrestore(&self->lock, flags);
                         dev_kfree_skb(skb);
                         return 0;
-                } else {
-                        self->new_speed = speed;
                 }
+                self->new_speed = speed;
         }
 
         /* Init tx buffer */
         self->tx_buff.data = self->tx_buff.head;
 
         /* Copy skb to tx_buff while wrapping, stuffing and making CRC */
-        self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, 
+        self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data,
                                            self->tx_buff.truesize);
-        
+
         self->stats.tx_bytes += self->tx_buff.len;
 
         /* Turn on transmit finished interrupt. Will fire immediately!  */
-        outb(UART_IER_THRI, iobase+UART_IER); 
+        outb(UART_IER_THRI, self->io.sir_base + UART_IER);
 
         spin_unlock_irqrestore(&self->lock, flags);
 
         dev_kfree_skb(skb);
-        
+
         return 0;
 }
 
@@ -826,9 +850,9 @@ static void smsc_ircc_set_fir_speed(struct smsc_ircc_cb *self, u32 speed)
 
         self->io.speed = speed;
 
-        switch(speed) {
+        switch (speed) {
         default:
-        case 576000:            
+        case 576000:
                 ir_mode = IRCC_CFGA_IRDA_HDLC;
                 ctrl = IRCC_CRC;
                 fast = 0;
@@ -853,14 +877,14 @@ static void smsc_ircc_set_fir_speed(struct smsc_ircc_cb *self, u32 speed)
         Now in tranceiver!
         /* This causes an interrupt */
         register_bank(fir_base, 0);
-        outb((inb(fir_base+IRCC_LCR_A) &  0xbf) | fast, fir_base+IRCC_LCR_A);
+        outb((inb(fir_base + IRCC_LCR_A) &  0xbf) | fast, fir_base + IRCC_LCR_A);
         #endif
-        
+
         register_bank(fir_base, 1);
-        outb(((inb(fir_base+IRCC_SCE_CFGA) & IRCC_SCE_CFGA_BLOCK_CTRL_BITS_MASK) | ir_mode), fir_base+IRCC_SCE_CFGA);
-        
+        outb(((inb(fir_base + IRCC_SCE_CFGA) & IRCC_SCE_CFGA_BLOCK_CTRL_BITS_MASK) | ir_mode), fir_base + IRCC_SCE_CFGA);
+
         register_bank(fir_base, 4);
-        outb((inb(fir_base+IRCC_CONTROL) & 0x30) | ctrl, fir_base+IRCC_CONTROL);
+        outb((inb(fir_base + IRCC_CONTROL) & 0x30) | ctrl, fir_base + IRCC_CONTROL);
 }
 
 /*
@@ -885,31 +909,31 @@ static void smsc_ircc_fir_start(struct smsc_ircc_cb *self)
         /* Reset everything */
 
         /* Install FIR transmit handler */
-        dev->hard_start_xmit = smsc_ircc_hard_xmit_fir; 
+        dev->hard_start_xmit = smsc_ircc_hard_xmit_fir;
 
         /* Clear FIFO */
-        outb(inb(fir_base+IRCC_LCR_A)|IRCC_LCR_A_FIFO_RESET, fir_base+IRCC_LCR_A);
+        outb(inb(fir_base + IRCC_LCR_A) | IRCC_LCR_A_FIFO_RESET, fir_base + IRCC_LCR_A);
 
         /* Enable interrupt */
-        /*outb(IRCC_IER_ACTIVE_FRAME|IRCC_IER_EOM, fir_base+IRCC_IER);*/
+        /*outb(IRCC_IER_ACTIVE_FRAME|IRCC_IER_EOM, fir_base + IRCC_IER);*/
 
         register_bank(fir_base, 1);
 
-        /* Select the TX/RX interface */        
+        /* Select the TX/RX interface */
 #ifdef SMSC_669 /* Uses pin 88/89 for Rx/Tx */
-        outb(((inb(fir_base+IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_COM), 
-             fir_base+IRCC_SCE_CFGB);
-#else   
-        outb(((inb(fir_base+IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_IR),
-             fir_base+IRCC_SCE_CFGB);
-#endif  
-        (void) inb(fir_base+IRCC_FIFO_THRESHOLD);
+        outb(((inb(fir_base + IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_COM),
+             fir_base + IRCC_SCE_CFGB);
+#else
+        outb(((inb(fir_base + IRCC_SCE_CFGB) & 0x3f) | IRCC_CFGB_MUX_IR),
+             fir_base + IRCC_SCE_CFGB);
+#endif
+        (void) inb(fir_base + IRCC_FIFO_THRESHOLD);
 
         /* Enable SCE interrupts */
-        outb(0, fir_base+IRCC_MASTER);
+        outb(0, fir_base + IRCC_MASTER);
         register_bank(fir_base, 0);
-        outb(IRCC_IER_ACTIVE_FRAME|IRCC_IER_EOM, fir_base+IRCC_IER);
-        outb(IRCC_MASTER_INT_EN, fir_base+IRCC_MASTER);
+        outb(IRCC_IER_ACTIVE_FRAME | IRCC_IER_EOM, fir_base + IRCC_IER);
+        outb(IRCC_MASTER_INT_EN, fir_base + IRCC_MASTER);
 }
 
 /*
@@ -923,13 +947,13 @@ static void smsc_ircc_fir_stop(struct smsc_ircc_cb *self)
         int fir_base;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
-        
+
         IRDA_ASSERT(self != NULL, return;);
 
         fir_base = self->io.fir_base;
         register_bank(fir_base, 0);
-        /*outb(IRCC_MASTER_RESET, fir_base+IRCC_MASTER);*/      
-        outb(inb(fir_base+IRCC_LCR_B) & IRCC_LCR_B_SIP_ENABLE, fir_base+IRCC_LCR_B);
+        /*outb(IRCC_MASTER_RESET, fir_base + IRCC_MASTER);*/
+        outb(inb(fir_base + IRCC_LCR_B) & IRCC_LCR_B_SIP_ENABLE, fir_base + IRCC_LCR_B);
 }
 
 
@@ -941,18 +965,15 @@ static void smsc_ircc_fir_stop(struct smsc_ircc_cb *self)
  * This function *must* be called with spinlock held, because it may
  * be called from the irq handler. - Jean II
  */
-static void smsc_ircc_change_speed(void *priv, u32 speed)
+static void smsc_ircc_change_speed(struct smsc_ircc_cb *self, u32 speed)
 {
-        struct smsc_ircc_cb *self = (struct smsc_ircc_cb *) priv;
         struct net_device *dev;
-        int iobase;
         int last_speed_was_sir;
-        
+
         IRDA_DEBUG(0, "%s() changing speed to: %d\n", __FUNCTION__, speed);
 
         IRDA_ASSERT(self != NULL, return;);
         dev = self->netdev;
-        iobase = self->io.fir_base;
 
         last_speed_was_sir = self->io.speed <= SMSC_IRCC2_MAX_SIR_SPEED;
 
@@ -961,30 +982,30 @@ static void smsc_ircc_change_speed(void *priv, u32 speed)
         speed= 1152000;
         self->io.speed = speed;
         last_speed_was_sir = 0;
-        smsc_ircc_fir_start(self);      
+        smsc_ircc_fir_start(self);
         #endif
-        
-        if(self->io.speed == 0)
+
+        if (self->io.speed == 0)
                 smsc_ircc_sir_start(self);
 
         #if 0
-        if(!last_speed_was_sir) speed = self->io.speed;
+        if (!last_speed_was_sir) speed = self->io.speed;
         #endif
 
-        if(self->io.speed != speed) smsc_ircc_set_transceiver_for_speed(self, speed);
+        if (self->io.speed != speed)
+                smsc_ircc_set_transceiver_for_speed(self, speed);
 
         self->io.speed = speed;
-        
-        if(speed <= SMSC_IRCC2_MAX_SIR_SPEED) {
-                if(!last_speed_was_sir) {
+
+        if (speed <= SMSC_IRCC2_MAX_SIR_SPEED) {
+                if (!last_speed_was_sir) {
                         smsc_ircc_fir_stop(self);
                         smsc_ircc_sir_start(self);
                 }
-                smsc_ircc_set_sir_speed(self, speed); 
-        }
-        else {
-                if(last_speed_was_sir) {
-                        #if SMSC_IRCC2_C_SIR_STOP               
+                smsc_ircc_set_sir_speed(self, speed);
+        } else {
+                if (last_speed_was_sir) {
+                        #if SMSC_IRCC2_C_SIR_STOP
                         smsc_ircc_sir_stop(self);
                         #endif
                         smsc_ircc_fir_start(self);
@@ -994,13 +1015,13 @@ static void smsc_ircc_change_speed(void *priv, u32 speed)
                 #if 0
                 self->tx_buff.len = 10;
                 self->tx_buff.data = self->tx_buff.head;
-                
-                smsc_ircc_dma_xmit(self, iobase, 4000);
+
+                smsc_ircc_dma_xmit(self, 4000);
                 #endif
                 /* Be ready for incoming frames */
-                smsc_ircc_dma_receive(self, iobase);
+                smsc_ircc_dma_receive(self);
         }
-        
+
         netif_wake_queue(dev);
 }
 
@@ -1010,10 +1031,9 @@ static void smsc_ircc_change_speed(void *priv, u32 speed)
  *    Set speed of IrDA port to specified baudrate
  *
  */
-void smsc_ircc_set_sir_speed(void *priv, __u32 speed)
+void smsc_ircc_set_sir_speed(struct smsc_ircc_cb *self, __u32 speed)
 {
-        struct smsc_ircc_cb *self = (struct smsc_ircc_cb *) priv;
-        int iobase; 
+        int iobase;
         int fcr;    /* FIFO control reg */
         int lcr;    /* Line control reg */
         int divisor;
@@ -1022,38 +1042,36 @@ void smsc_ircc_set_sir_speed(void *priv, __u32 speed)
 
         IRDA_ASSERT(self != NULL, return;);
         iobase = self->io.sir_base;
-        
+
         /* Update accounting for new speed */
         self->io.speed = speed;
 
         /* Turn off interrupts */
-        outb(0, iobase+UART_IER); 
+        outb(0, iobase + UART_IER);
+
+        divisor = SMSC_IRCC2_MAX_SIR_SPEED / speed;
 
-        divisor = SMSC_IRCC2_MAX_SIR_SPEED/speed;
-        
         fcr = UART_FCR_ENABLE_FIFO;
 
-        /* 
+        /*
          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
-         * about this timeout since it will always be fast enough. 
+         * about this timeout since it will always be fast enough.
          */
-        if (self->io.speed < 38400)
-                fcr |= UART_FCR_TRIGGER_1;
-        else 
-                fcr |= UART_FCR_TRIGGER_14;
-        
+        fcr |= self->io.speed < 38400 ?
+                UART_FCR_TRIGGER_1 : UART_FCR_TRIGGER_14;
+
         /* IrDA ports use 8N1 */
         lcr = UART_LCR_WLEN8;
-        
-        outb(UART_LCR_DLAB | lcr, iobase+UART_LCR); /* Set DLAB */
-        outb(divisor & 0xff,      iobase+UART_DLL); /* Set speed */
-        outb(divisor >> 8,        iobase+UART_DLM);
-        outb(lcr,                 iobase+UART_LCR); /* Set 8N1  */
-        outb(fcr,                 iobase+UART_FCR); /* Enable FIFO's */
+
+        outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
+        outb(divisor & 0xff,      iobase + UART_DLL); /* Set speed */
+        outb(divisor >> 8,        iobase + UART_DLM);
+        outb(lcr,                 iobase + UART_LCR); /* Set 8N1 */
+        outb(fcr,                 iobase + UART_FCR); /* Enable FIFO's */
 
         /* Turn on interrups */
-        outb(UART_IER_RLSI|UART_IER_RDI|UART_IER_THRI, iobase+UART_IER);
+        outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 
         IRDA_DEBUG(2, "%s() speed changed to: %d\n", __FUNCTION__, speed);
 }
@@ -1070,15 +1088,12 @@ static int smsc_ircc_hard_xmit_fir(struct sk_buff *skb, struct net_device *dev)
         struct smsc_ircc_cb *self;
         unsigned long flags;
         s32 speed;
-        int iobase;
         int mtt;
 
         IRDA_ASSERT(dev != NULL, return 0;);
-        self = (struct smsc_ircc_cb *) dev->priv;
+        self = netdev_priv(dev);
         IRDA_ASSERT(self != NULL, return 0;);
 
-        iobase = self->io.fir_base;
-
         netif_stop_queue(dev);
 
         /* Make sure test of self->io.speed & speed change are atomic */
@@ -1086,30 +1101,31 @@ static int smsc_ircc_hard_xmit_fir(struct sk_buff *skb, struct net_device *dev)
 
         /* Check if we need to change the speed after this frame */
         speed = irda_get_next_speed(skb);
-        if ((speed != self->io.speed) && (speed != -1)) {
+        if (speed != self->io.speed && speed != -1) {
                 /* Check for empty frame */
                 if (!skb->len) {
                         /* Note : you should make sure that speed changes
                          * are not going to corrupt any outgoing frame.
                          * Look at nsc-ircc for the gory details - Jean II */
-                        smsc_ircc_change_speed(self, speed); 
+                        smsc_ircc_change_speed(self, speed);
                         spin_unlock_irqrestore(&self->lock, flags);
                         dev_kfree_skb(skb);
                         return 0;
-                } else
-                        self->new_speed = speed;
+                }
+
+                self->new_speed = speed;
         }
-        
+
         memcpy(self->tx_buff.head, skb->data, skb->len);
 
         self->tx_buff.len = skb->len;
         self->tx_buff.data = self->tx_buff.head;
-        
-        mtt = irda_get_mtt(skb);        
+
+        mtt = irda_get_mtt(skb);
         if (mtt) {
                 int bofs;
 
-                /* 
+                /*
                  * Compute how many BOFs (STA or PA's) we need to waste the
                  * min turn time given the speed of the link.
                  */
@@ -1117,11 +1133,12 @@ static int smsc_ircc_hard_xmit_fir(struct sk_buff *skb, struct net_device *dev)
                 if (bofs > 4095)
                         bofs = 4095;
 
-                smsc_ircc_dma_xmit(self, iobase, bofs);
+                smsc_ircc_dma_xmit(self, bofs);
         } else {
                 /* Transmit frame */
-                smsc_ircc_dma_xmit(self, iobase, 0);
+                smsc_ircc_dma_xmit(self, 0);
         }
+
         spin_unlock_irqrestore(&self->lock, flags);
         dev_kfree_skb(skb);
 
@@ -1129,43 +1146,44 @@ static int smsc_ircc_hard_xmit_fir(struct sk_buff *skb, struct net_device *dev)
 }
 
 /*
- * Function smsc_ircc_dma_xmit (self, iobase)
+ * Function smsc_ircc_dma_xmit (self, bofs)
  *
  *    Transmit data using DMA
  *
  */
-static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int iobase, int bofs)
+static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int bofs)
 {
+        int iobase = self->io.fir_base;
         u8 ctrl;
 
         IRDA_DEBUG(3, "%s\n", __FUNCTION__);
 #if 1
         /* Disable Rx */
         register_bank(iobase, 0);
-        outb(0x00, iobase+IRCC_LCR_B);
+        outb(0x00, iobase + IRCC_LCR_B);
 #endif
         register_bank(iobase, 1);
-        outb(inb(iobase+IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE, 
-             iobase+IRCC_SCE_CFGB);
+        outb(inb(iobase + IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE,
+             iobase + IRCC_SCE_CFGB);
 
         self->io.direction = IO_XMIT;
 
         /* Set BOF additional count for generating the min turn time */
         register_bank(iobase, 4);
-        outb(bofs & 0xff, iobase+IRCC_BOF_COUNT_LO);
-        ctrl = inb(iobase+IRCC_CONTROL) & 0xf0;
-        outb(ctrl | ((bofs >> 8) & 0x0f), iobase+IRCC_BOF_COUNT_HI);
+        outb(bofs & 0xff, iobase + IRCC_BOF_COUNT_LO);
+        ctrl = inb(iobase + IRCC_CONTROL) & 0xf0;
+        outb(ctrl | ((bofs >> 8) & 0x0f), iobase + IRCC_BOF_COUNT_HI);
 
         /* Set max Tx frame size */
-        outb(self->tx_buff.len >> 8, iobase+IRCC_TX_SIZE_HI);
-        outb(self->tx_buff.len & 0xff, iobase+IRCC_TX_SIZE_LO);
+        outb(self->tx_buff.len >> 8, iobase + IRCC_TX_SIZE_HI);
+        outb(self->tx_buff.len & 0xff, iobase + IRCC_TX_SIZE_LO);
 
         /*outb(UART_MCR_OUT2, self->io.sir_base + UART_MCR);*/
-        
+
         /* Enable burst mode chip Tx DMA */
         register_bank(iobase, 1);
-        outb(inb(iobase+IRCC_SCE_CFGB) | IRCC_CFGB_DMA_ENABLE |
-             IRCC_CFGB_DMA_BURST, iobase+IRCC_SCE_CFGB);
+        outb(inb(iobase + IRCC_SCE_CFGB) | IRCC_CFGB_DMA_ENABLE |
+             IRCC_CFGB_DMA_BURST, iobase + IRCC_SCE_CFGB);
 
         /* Setup DMA controller (must be done after enabling chip DMA) */
         irda_setup_dma(self->io.dma, self->tx_buff_dma, self->tx_buff.len,
@@ -1174,50 +1192,52 @@ static void smsc_ircc_dma_xmit(struct smsc_ircc_cb *self, int iobase, int bofs)
         /* Enable interrupt */
 
         register_bank(iobase, 0);
-        outb(IRCC_IER_ACTIVE_FRAME | IRCC_IER_EOM, iobase+IRCC_IER);
-        outb(IRCC_MASTER_INT_EN, iobase+IRCC_MASTER);
-        
+        outb(IRCC_IER_ACTIVE_FRAME | IRCC_IER_EOM, iobase + IRCC_IER);
+        outb(IRCC_MASTER_INT_EN, iobase + IRCC_MASTER);
+
         /* Enable transmit */
-        outb(IRCC_LCR_B_SCE_TRANSMIT | IRCC_LCR_B_SIP_ENABLE, iobase+IRCC_LCR_B);
+        outb(IRCC_LCR_B_SCE_TRANSMIT | IRCC_LCR_B_SIP_ENABLE, iobase + IRCC_LCR_B);
 }
 
 /*
  * Function smsc_ircc_dma_xmit_complete (self)
  *
- *    The transfer of a frame in finished. This function will only be called 
+ *    The transfer of a frame in finished. This function will only be called
  *    by the interrupt handler
  *
  */
-static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self, int iobase)
+static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self)
 {
+        int iobase = self->io.fir_base;
+
         IRDA_DEBUG(3, "%s\n", __FUNCTION__);
 #if 0
         /* Disable Tx */
         register_bank(iobase, 0);
-        outb(0x00, iobase+IRCC_LCR_B);
+        outb(0x00, iobase + IRCC_LCR_B);
 #endif
-        register_bank(self->io.fir_base, 1);
-        outb(inb(self->io.fir_base+IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE,
-             self->io.fir_base+IRCC_SCE_CFGB);
+        register_bank(iobase, 1);
+        outb(inb(iobase + IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE,
+             iobase + IRCC_SCE_CFGB);
 
         /* Check for underrun! */
         register_bank(iobase, 0);
-        if (inb(iobase+IRCC_LSR) & IRCC_LSR_UNDERRUN) {
+        if (inb(iobase + IRCC_LSR) & IRCC_LSR_UNDERRUN) {
                 self->stats.tx_errors++;
                 self->stats.tx_fifo_errors++;
 
                 /* Reset error condition */
                 register_bank(iobase, 0);
-                outb(IRCC_MASTER_ERROR_RESET, iobase+IRCC_MASTER);
-                outb(0x00, iobase+IRCC_MASTER);
+                outb(IRCC_MASTER_ERROR_RESET, iobase + IRCC_MASTER);
+                outb(0x00, iobase + IRCC_MASTER);
         } else {
                 self->stats.tx_packets++;
-                self->stats.tx_bytes +=  self->tx_buff.len;
+                self->stats.tx_bytes += self->tx_buff.len;
         }
 
         /* Check if it's time to change the speed */
         if (self->new_speed) {
-                smsc_ircc_change_speed(self, self->new_speed);          
+                smsc_ircc_change_speed(self, self->new_speed);
                 self->new_speed = 0;
         }
 
@@ -1231,31 +1251,32 @@ static void smsc_ircc_dma_xmit_complete(struct smsc_ircc_cb *self, int iobase)
  *    if it starts to receive a frame.
  *
  */
-static int smsc_ircc_dma_receive(struct smsc_ircc_cb *self, int iobase) 
+static int smsc_ircc_dma_receive(struct smsc_ircc_cb *self)
 {
+        int iobase = self->io.fir_base;
 #if 0
         /* Turn off chip DMA */
         register_bank(iobase, 1);
-        outb(inb(iobase+IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE, 
-             iobase+IRCC_SCE_CFGB);
+        outb(inb(iobase + IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE,
+             iobase + IRCC_SCE_CFGB);
 #endif
-        
+
         /* Disable Tx */
         register_bank(iobase, 0);
-        outb(0x00, iobase+IRCC_LCR_B);
+        outb(0x00, iobase + IRCC_LCR_B);
 
         /* Turn off chip DMA */
         register_bank(iobase, 1);
-        outb(inb(iobase+IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE, 
-             iobase+IRCC_SCE_CFGB);
+        outb(inb(iobase + IRCC_SCE_CFGB) & ~IRCC_CFGB_DMA_ENABLE,
+             iobase + IRCC_SCE_CFGB);
 
         self->io.direction = IO_RECV;
         self->rx_buff.data = self->rx_buff.head;
 
         /* Set max Rx frame size */
         register_bank(iobase, 4);
-        outb((2050 >> 8) & 0x0f, iobase+IRCC_RX_SIZE_HI);
-        outb(2050 & 0xff, iobase+IRCC_RX_SIZE_LO);
+        outb((2050 >> 8) & 0x0f, iobase + IRCC_RX_SIZE_HI);
+        outb(2050 & 0xff, iobase + IRCC_RX_SIZE_LO);
 
         /* Setup DMA controller */
         irda_setup_dma(self->io.dma, self->rx_buff_dma, self->rx_buff.truesize,
@@ -1263,83 +1284,83 @@ static int smsc_ircc_dma_receive(struct smsc_ircc_cb *self, int iobase)
 
         /* Enable burst mode chip Rx DMA */
         register_bank(iobase, 1);
-        outb(inb(iobase+IRCC_SCE_CFGB) | IRCC_CFGB_DMA_ENABLE | 
-             IRCC_CFGB_DMA_BURST, iobase+IRCC_SCE_CFGB);
+        outb(inb(iobase + IRCC_SCE_CFGB) | IRCC_CFGB_DMA_ENABLE |
+             IRCC_CFGB_DMA_BURST, iobase + IRCC_SCE_CFGB);
 
         /* Enable interrupt */
         register_bank(iobase, 0);
-        outb(IRCC_IER_ACTIVE_FRAME | IRCC_IER_EOM, iobase+IRCC_IER);
-        outb(IRCC_MASTER_INT_EN, iobase+IRCC_MASTER);
-
+        outb(IRCC_IER_ACTIVE_FRAME | IRCC_IER_EOM, iobase + IRCC_IER);
+        outb(IRCC_MASTER_INT_EN, iobase + IRCC_MASTER);
 
         /* Enable receiver */
         register_bank(iobase, 0);
-        outb(IRCC_LCR_B_SCE_RECEIVE | IRCC_LCR_B_SIP_ENABLE, 
-             iobase+IRCC_LCR_B);
-        
+        outb(IRCC_LCR_B_SCE_RECEIVE | IRCC_LCR_B_SIP_ENABLE,
+             iobase + IRCC_LCR_B);
+
         return 0;
 }
 
 /*
- * Function smsc_ircc_dma_receive_complete(self, iobase)
+ * Function smsc_ircc_dma_receive_complete(self)
  *
  *    Finished with receiving frames
  *
  */
-static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self, int iobase)
+static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self)
 {
         struct sk_buff *skb;
         int len, msgcnt, lsr;
-        
+        int iobase = self->io.fir_base;
+
         register_bank(iobase, 0);
-        
+
         IRDA_DEBUG(3, "%s\n", __FUNCTION__);
 #if 0
         /* Disable Rx */
         register_bank(iobase, 0);
-        outb(0x00, iobase+IRCC_LCR_B);
+        outb(0x00, iobase + IRCC_LCR_B);
 #endif
         register_bank(iobase, 0);
-        outb(inb(iobase+IRCC_LSAR) & ~IRCC_LSAR_ADDRESS_MASK, iobase+IRCC_LSAR);
-        lsr= inb(iobase+IRCC_LSR);
-        msgcnt = inb(iobase+IRCC_LCR_B) & 0x08;
+        outb(inb(iobase + IRCC_LSAR) & ~IRCC_LSAR_ADDRESS_MASK, iobase + IRCC_LSAR);
+        lsr= inb(iobase + IRCC_LSR);
+        msgcnt = inb(iobase + IRCC_LCR_B) & 0x08;
 
         IRDA_DEBUG(2, "%s: dma count = %d\n", __FUNCTION__,
                    get_dma_residue(self->io.dma));
 
         len = self->rx_buff.truesize - get_dma_residue(self->io.dma);
 
-        /* Look for errors 
-         */     
-
-        if(lsr & (IRCC_LSR_FRAME_ERROR | IRCC_LSR_CRC_ERROR | IRCC_LSR_SIZE_ERROR)) {
+        /* Look for errors */
+        if (lsr & (IRCC_LSR_FRAME_ERROR | IRCC_LSR_CRC_ERROR | IRCC_LSR_SIZE_ERROR)) {
                 self->stats.rx_errors++;
-                if(lsr & IRCC_LSR_FRAME_ERROR) self->stats.rx_frame_errors++;
-                if(lsr & IRCC_LSR_CRC_ERROR) self->stats.rx_crc_errors++;
-                if(lsr & IRCC_LSR_SIZE_ERROR) self->stats.rx_length_errors++;
-                if(lsr & (IRCC_LSR_UNDERRUN | IRCC_LSR_OVERRUN)) self->stats.rx_length_errors++;
+                if (lsr & IRCC_LSR_FRAME_ERROR)
+                        self->stats.rx_frame_errors++;
+                if (lsr & IRCC_LSR_CRC_ERROR)
+                        self->stats.rx_crc_errors++;
+                if (lsr & IRCC_LSR_SIZE_ERROR)
+                        self->stats.rx_length_errors++;
+                if (lsr & (IRCC_LSR_UNDERRUN | IRCC_LSR_OVERRUN))
+                        self->stats.rx_length_errors++;
                 return;
         }
+
         /* Remove CRC */
-        if (self->io.speed < 4000000)
-                len -= 2;
-        else
-                len -= 4;
+        len -= self->io.speed < 4000000 ? 2 : 4;
 
-        if ((len < 2) || (len > 2050)) {
+        if (len < 2 || len > 2050) {
                 IRDA_WARNING("%s(), bogus len=%d\n", __FUNCTION__, len);
                 return;
         }
         IRDA_DEBUG(2, "%s: msgcnt = %d, len=%d\n", __FUNCTION__, msgcnt, len);
 
-        skb = dev_alloc_skb(len+1);
-        if (!skb)  {
+        skb = dev_alloc_skb(len + 1);
+        if (!skb) {
                 IRDA_WARNING("%s(), memory squeeze, dropping frame.\n",
                              __FUNCTION__);
                 return;
-        }                       
+        }
         /* Make sure IP header gets aligned */
-        skb_reserve(skb, 1); 
+        skb_reserve(skb, 1);
 
         memcpy(skb_put(skb, len), self->rx_buff.data, len);
         self->stats.rx_packets++;
@@ -1357,7 +1378,7 @@ static void smsc_ircc_dma_receive_complete(struct smsc_ircc_cb *self, int iobase
  *    Receive one frame from the infrared port
  *
  */
-static void smsc_ircc_sir_receive(struct smsc_ircc_cb *self) 
+static void smsc_ircc_sir_receive(struct smsc_ircc_cb *self)
 {
         int boguscount = 0;
         int iobase;
@@ -1366,20 +1387,20 @@ static void smsc_ircc_sir_receive(struct smsc_ircc_cb *self)
 
         iobase = self->io.sir_base;
 
-        /*  
-         * Receive all characters in Rx FIFO, unwrap and unstuff them. 
-         * async_unwrap_char will deliver all found frames  
+        /*
+         * Receive all characters in Rx FIFO, unwrap and unstuff them.
+         * async_unwrap_char will deliver all found frames
          */
         do {
-                async_unwrap_char(self->netdev, &self->stats, &self->rx_buff, 
-                                  inb(iobase+UART_RX));
+                async_unwrap_char(self->netdev, &self->stats, &self->rx_buff,
+                                  inb(iobase + UART_RX));
 
                 /* Make sure we don't stay here to long */
                 if (boguscount++ > 32) {
                         IRDA_DEBUG(2, "%s(), breaking!\n", __FUNCTION__);
                         break;
                 }
-        } while (inb(iobase+UART_LSR) & UART_LSR_DR);   
+        } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 }
 
 
@@ -1397,18 +1418,19 @@ static irqreturn_t smsc_ircc_interrupt(int irq, void *dev_id, struct pt_regs *re
         irqreturn_t ret = IRQ_NONE;
 
         if (dev == NULL) {
-                printk(KERN_WARNING "%s: irq %d for unknown device.\n", 
+                printk(KERN_WARNING "%s: irq %d for unknown device.\n",
                        driver_name, irq);
                 goto irq_ret;
         }
-        self = (struct smsc_ircc_cb *) dev->priv;
+
+        self = netdev_priv(dev);
         IRDA_ASSERT(self != NULL, return IRQ_NONE;);
 
         /* Serialise the interrupt handler in various CPUs, stop Tx path */
-        spin_lock(&self->lock); 
+        spin_lock(&self->lock);
 
         /* Check if we should use the SIR interrupt handler */
-        if (self->io.speed <=  SMSC_IRCC2_MAX_SIR_SPEED) {
+        if (self->io.speed <= SMSC_IRCC2_MAX_SIR_SPEED) {
                 ret = smsc_ircc_interrupt_sir(dev);
                 goto irq_ret_unlock;
         }
@@ -1416,25 +1438,25 @@ static irqreturn_t smsc_ircc_interrupt(int irq, void *dev_id, struct pt_regs *re
         iobase = self->io.fir_base;
 
         register_bank(iobase, 0);
-        iir = inb(iobase+IRCC_IIR);
-        if (iir == 0) 
+        iir = inb(iobase + IRCC_IIR);
+        if (iir == 0)
                 goto irq_ret_unlock;
         ret = IRQ_HANDLED;
 
         /* Disable interrupts */
-        outb(0, iobase+IRCC_IER);
-        lcra = inb(iobase+IRCC_LCR_A);
-        lsr = inb(iobase+IRCC_LSR);
-        
+        outb(0, iobase + IRCC_IER);
+        lcra = inb(iobase + IRCC_LCR_A);
+        lsr = inb(iobase + IRCC_LSR);
+
         IRDA_DEBUG(2, "%s(), iir = 0x%02x\n", __FUNCTION__, iir);
 
         if (iir & IRCC_IIR_EOM) {
                 if (self->io.direction == IO_RECV)
-                        smsc_ircc_dma_receive_complete(self, iobase);
+                        smsc_ircc_dma_receive_complete(self);
                 else
-                        smsc_ircc_dma_xmit_complete(self, iobase);
-                
-                smsc_ircc_dma_receive(self, iobase);
+                        smsc_ircc_dma_xmit_complete(self);
+
+                smsc_ircc_dma_receive(self);
         }
 
         if (iir & IRCC_IIR_ACTIVE_FRAME) {
@@ -1444,7 +1466,7 @@ static irqreturn_t smsc_ircc_interrupt(int irq, void *dev_id, struct pt_regs *re
         /* Enable interrupts again */
 
         register_bank(iobase, 0);
-        outb(IRCC_IER_ACTIVE_FRAME|IRCC_IER_EOM, iobase+IRCC_IER);
+        outb(IRCC_IER_ACTIVE_FRAME | IRCC_IER_EOM, iobase + IRCC_IER);
 
  irq_ret_unlock:
         spin_unlock(&self->lock);
@@ -1459,7 +1481,7 @@ static irqreturn_t smsc_ircc_interrupt(int irq, void *dev_id, struct pt_regs *re
  */
 static irqreturn_t smsc_ircc_interrupt_sir(struct net_device *dev)
 {
-        struct smsc_ircc_cb *self = dev->priv;
+        struct smsc_ircc_cb *self = netdev_priv(dev);
         int boguscount = 0;
         int iobase;
         int iir, lsr;
@@ -1469,14 +1491,14 @@ static irqreturn_t smsc_ircc_interrupt_sir(struct net_device *dev)
 
         iobase = self->io.sir_base;
 
-        iir = inb(iobase+UART_IIR) & UART_IIR_ID;
+        iir = inb(iobase + UART_IIR) & UART_IIR_ID;
         if (iir == 0)
                 return IRQ_NONE;
         while (iir) {
                 /* Clear interrupt */
-                lsr = inb(iobase+UART_LSR);
+                lsr = inb(iobase + UART_LSR);
 
-                IRDA_DEBUG(4, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n", 
+                IRDA_DEBUG(4, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n",
                             __FUNCTION__, iir, lsr, iobase);
 
                 switch (iir) {
@@ -1496,13 +1518,13 @@ static irqreturn_t smsc_ircc_interrupt_sir(struct net_device *dev)
                         IRDA_DEBUG(0, "%s(), unhandled IIR=%#x\n",
                                    __FUNCTION__, iir);
                         break;
-                } 
-                
+                }
+
                 /* Make sure we don't stay here to long */
                 if (boguscount++ > 100)
                         break;
 
-                iir = inb(iobase + UART_IIR) & UART_IIR_ID;
+                iir = inb(iobase + UART_IIR) & UART_IIR_ID;
         }
         /*spin_unlock(&self->lock);*/
         return IRQ_HANDLED;
@@ -1529,7 +1551,7 @@ static int ircc_is_receiving(struct smsc_ircc_cb *self)
                    get_dma_residue(self->io.dma));
 
         status = (self->rx_buff.state != OUTSIDE_FRAME);
-        
+
         return status;
 }
 #endif /* unused */
@@ -1544,19 +1566,16 @@ static int ircc_is_receiving(struct smsc_ircc_cb *self)
 static int smsc_ircc_net_open(struct net_device *dev)
 {
         struct smsc_ircc_cb *self;
-        int iobase;
         char hwname[16];
         unsigned long flags;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
-        
+
         IRDA_ASSERT(dev != NULL, return -1;);
-        self = (struct smsc_ircc_cb *) dev->priv;
+        self = netdev_priv(dev);
         IRDA_ASSERT(self != NULL, return 0;);
-        
-        iobase = self->io.fir_base;
 
-        if (request_irq(self->io.irq, smsc_ircc_interrupt, 0, dev->name, 
+        if (request_irq(self->io.irq, smsc_ircc_interrupt, 0, dev->name,
                         (void *) dev)) {
                 IRDA_DEBUG(0, "%s(), unable to allocate irq=%d\n",
                            __FUNCTION__, self->io.irq);
@@ -1568,14 +1587,14 @@ static int smsc_ircc_net_open(struct net_device *dev)
         self->io.speed = 0;
         smsc_ircc_change_speed(self, SMSC_IRCC2_C_IRDA_FALLBACK_SPEED);
         spin_unlock_irqrestore(&self->lock, flags);
-        
+
         /* Give self a hardware name */
         /* It would be cool to offer the chip revision here - Jean II */
         sprintf(hwname, "SMSC @ 0x%03x", self->io.fir_base);
 
-        /* 
+        /*
          * Open new IrLAP layer instance, now that everything should be
-         * initialized properly 
+         * initialized properly
          */
         self->irlap = irlap_open(dev, &self->qos, hwname);
 
@@ -1590,7 +1609,7 @@ static int smsc_ircc_net_open(struct net_device *dev)
                              __FUNCTION__, self->io.dma);
                 return -EAGAIN;
         }
-        
+
         netif_start_queue(dev);
 
         return 0;
@@ -1605,73 +1624,53 @@ static int smsc_ircc_net_open(struct net_device *dev)
 static int smsc_ircc_net_close(struct net_device *dev)
 {
         struct smsc_ircc_cb *self;
-        int iobase;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
-        
+
         IRDA_ASSERT(dev != NULL, return -1;);
-        self = (struct smsc_ircc_cb *) dev->priv;       
+        self = netdev_priv(dev);
         IRDA_ASSERT(self != NULL, return 0;);
-        
-        iobase = self->io.fir_base;
 
         /* Stop device */
         netif_stop_queue(dev);
-        
+
         /* Stop and remove instance of IrLAP */
         if (self->irlap)
                 irlap_close(self->irlap);
         self->irlap = NULL;
 
         free_irq(self->io.irq, dev);
-
         disable_dma(self->io.dma);
-
         free_dma(self->io.dma);
 
         return 0;
 }
 
-
-static void smsc_ircc_suspend(struct smsc_ircc_cb *self)
+static int smsc_ircc_suspend(struct device *dev, pm_message_t state, u32 level)
 {
-        IRDA_MESSAGE("%s, Suspending\n", driver_name);
+        struct smsc_ircc_cb *self = dev_get_drvdata(dev);
 
-        if (self->io.suspended)
-                return;
+        IRDA_MESSAGE("%s, Suspending\n", driver_name);
 
-        smsc_ircc_net_close(self->netdev);
+        if (level == SUSPEND_DISABLE && !self->io.suspended) {
+                smsc_ircc_net_close(self->netdev);
+                self->io.suspended = 1;
+        }
 
-        self->io.suspended = 1;
+        return 0;
 }
 
-static void smsc_ircc_wakeup(struct smsc_ircc_cb *self)
+static int smsc_ircc_resume(struct device *dev, u32 level)
 {
-        if (!self->io.suspended)
-                return;
+        struct smsc_ircc_cb *self = dev_get_drvdata(dev);
 
-        /* The code was doing a "cli()" here, but this can't be right.
-         * If you need protection, do it in net_open with a spinlock
-         * or give a good reason. - Jean II */
+        if (level == RESUME_ENABLE && self->io.suspended) {
 
-        smsc_ircc_net_open(self->netdev);
-        
-        IRDA_MESSAGE("%s, Waking up\n", driver_name);
-}
+                smsc_ircc_net_open(self->netdev);
+                self->io.suspended = 0;
 
-static int smsc_ircc_pmproc(struct pm_dev *dev, pm_request_t rqst, void *data)
-{
-        struct smsc_ircc_cb *self = (struct smsc_ircc_cb*) dev->data;
-        if (self) {
-                switch (rqst) {
-                case PM_SUSPEND:
-                        smsc_ircc_suspend(self);
-                        break;
-                case PM_RESUME:
-                        smsc_ircc_wakeup(self);
-                        break;
-                }
-        }
+                IRDA_MESSAGE("%s, Waking up\n", driver_name);
+        }
         return 0;
 }
 
@@ -1690,10 +1689,7 @@ static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
 
         IRDA_ASSERT(self != NULL, return -1;);
 
-        iobase = self->io.fir_base;
-
-        if (self->pmdev)
-                pm_unregister(self->pmdev);
+        platform_device_unregister(self->pldev);
 
         /* Remove netdevice */
         unregister_netdev(self->netdev);
@@ -1702,15 +1698,16 @@ static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
         spin_lock_irqsave(&self->lock, flags);
 
         /* Stop interrupts */
+        iobase = self->io.fir_base;
         register_bank(iobase, 0);
-        outb(0, iobase+IRCC_IER);
-        outb(IRCC_MASTER_RESET, iobase+IRCC_MASTER);
-        outb(0x00, iobase+IRCC_MASTER);
+        outb(0, iobase + IRCC_IER);
+        outb(IRCC_MASTER_RESET, iobase + IRCC_MASTER);
+        outb(0x00, iobase + IRCC_MASTER);
 #if 0
         /* Reset to SIR mode */
         register_bank(iobase, 1);
-        outb(IRCC_CFGA_IRDA_SIR_A|IRCC_CFGA_TX_POLARITY, iobase+IRCC_SCE_CFGA);
-        outb(IRCC_CFGB_IR, iobase+IRCC_SCE_CFGB);
+        outb(IRCC_CFGA_IRDA_SIR_A|IRCC_CFGA_TX_POLARITY, iobase + IRCC_SCE_CFGA);
+        outb(IRCC_CFGB_IR, iobase + IRCC_SCE_CFGB);
 #endif
         spin_unlock_irqrestore(&self->lock, flags);
 
@@ -1720,7 +1717,7 @@ static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
 
         release_region(self->io.fir_base, self->io.fir_ext);
 
-        IRDA_DEBUG(0, "%s(), releasing 0x%03x\n", __FUNCTION__, 
+        IRDA_DEBUG(0, "%s(), releasing 0x%03x\n", __FUNCTION__,
                    self->io.sir_base);
 
         release_region(self->io.sir_base, self->io.sir_ext);
@@ -1728,7 +1725,7 @@ static int __exit smsc_ircc_close(struct smsc_ircc_cb *self)
         if (self->tx_buff.head)
                 dma_free_coherent(NULL, self->tx_buff.truesize,
                                   self->tx_buff.head, self->tx_buff_dma);
-        
+
         if (self->rx_buff.head)
                 dma_free_coherent(NULL, self->rx_buff.truesize,
                                   self->rx_buff.head, self->rx_buff_dma);
@@ -1744,10 +1741,12 @@ static void __exit smsc_ircc_cleanup(void)
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
-        for (i=0; i < 2; i++) {
+        for (i = 0; i < 2; i++) {
                 if (dev_self[i])
                         smsc_ircc_close(dev_self[i]);
         }
+
+        driver_unregister(&smsc_ircc_driver);
 }
 
 /*
@@ -1763,34 +1762,34 @@ void smsc_ircc_sir_start(struct smsc_ircc_cb *self)
 
         IRDA_DEBUG(3, "%s\n", __FUNCTION__);
 
-        IRDA_ASSERT(self != NULL, return;);     
-        dev= self->netdev;
-        IRDA_ASSERT(dev != NULL, return;);              
+        IRDA_ASSERT(self != NULL, return;);
+        dev = self->netdev;
+        IRDA_ASSERT(dev != NULL, return;);
         dev->hard_start_xmit = &smsc_ircc_hard_xmit_sir;
 
         fir_base = self->io.fir_base;
         sir_base = self->io.sir_base;
 
         /* Reset everything */
-        outb(IRCC_MASTER_RESET, fir_base+IRCC_MASTER);
+        outb(IRCC_MASTER_RESET, fir_base + IRCC_MASTER);
 
         #if SMSC_IRCC2_C_SIR_STOP
         /*smsc_ircc_sir_stop(self);*/
         #endif
 
         register_bank(fir_base, 1);
-        outb(((inb(fir_base+IRCC_SCE_CFGA) & IRCC_SCE_CFGA_BLOCK_CTRL_BITS_MASK) | IRCC_CFGA_IRDA_SIR_A), fir_base+IRCC_SCE_CFGA);
+        outb(((inb(fir_base + IRCC_SCE_CFGA) & IRCC_SCE_CFGA_BLOCK_CTRL_BITS_MASK) | IRCC_CFGA_IRDA_SIR_A), fir_base + IRCC_SCE_CFGA);
 
         /* Initialize UART */
-        outb(UART_LCR_WLEN8, sir_base+UART_LCR);  /* Reset DLAB */
-        outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), sir_base+UART_MCR);
-        
+        outb(UART_LCR_WLEN8, sir_base + UART_LCR);  /* Reset DLAB */
+        outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), sir_base + UART_MCR);
+
         /* Turn on interrups */
-        outb(UART_IER_RLSI | UART_IER_RDI |UART_IER_THRI, sir_base+UART_IER);
+        outb(UART_IER_RLSI | UART_IER_RDI |UART_IER_THRI, sir_base + UART_IER);
 
         IRDA_DEBUG(3, "%s() - exit\n", __FUNCTION__);
 
-        outb(0x00, fir_base+IRCC_MASTER);
+        outb(0x00, fir_base + IRCC_MASTER);
 }
 
 #if SMSC_IRCC2_C_SIR_STOP
@@ -1802,10 +1801,10 @@ void smsc_ircc_sir_stop(struct smsc_ircc_cb *self)
         iobase = self->io.sir_base;
 
         /* Reset UART */
-        outb(0, iobase+UART_MCR);
-        
+        outb(0, iobase + UART_MCR);
+
         /* Turn off interrupts */
-        outb(0, iobase+UART_IER);
+        outb(0, iobase + UART_IER);
 }
 #endif
 
@@ -1831,16 +1830,16 @@ static void smsc_ircc_sir_write_wakeup(struct smsc_ircc_cb *self)
         /* Finished with frame?  */
         if (self->tx_buff.len > 0)  {
                 /* Write data left in transmit buffer */
-                actual = smsc_ircc_sir_write(iobase, self->io.fifo_size, 
+                actual = smsc_ircc_sir_write(iobase, self->io.fifo_size,
                                       self->tx_buff.data, self->tx_buff.len);
                 self->tx_buff.data += actual;
                 self->tx_buff.len  -= actual;
         } else {
-        
+
         /*if (self->tx_buff.len ==0)  {*/
-                
-                /* 
-                 *  Now serial buffer is almost free & we can start 
+
+                /*
+                 *  Now serial buffer is almost free & we can start
                  *  transmission of another packet. But first we must check
                  *  if we need to change the speed of the hardware
                  */
@@ -1856,21 +1855,19 @@ static void smsc_ircc_sir_write_wakeup(struct smsc_ircc_cb *self)
                 }
                 self->stats.tx_packets++;
 
-                if(self->io.speed <= 115200) {
-                /* 
-                 * Reset Rx FIFO to make sure that all reflected transmit data
-                 * is discarded. This is needed for half duplex operation
-                 */
-                fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR;
-                if (self->io.speed < 38400)
-                        fcr |= UART_FCR_TRIGGER_1;
-                else 
-                        fcr |= UART_FCR_TRIGGER_14;
+                if (self->io.speed <= 115200) {
+                        /*
+                         * Reset Rx FIFO to make sure that all reflected transmit data
+                         * is discarded. This is needed for half duplex operation
+                         */
+                        fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR;
+                        fcr |= self->io.speed < 38400 ?
+                                        UART_FCR_TRIGGER_1 : UART_FCR_TRIGGER_14;
 
-                outb(fcr, iobase+UART_FCR);
+                        outb(fcr, iobase + UART_FCR);
 
-                /* Turn on receive interrupts */
-                outb(UART_IER_RDI, iobase+UART_IER);
+                        /* Turn on receive interrupts */
+                        outb(UART_IER_RDI, iobase + UART_IER);
                 }
         }
 }
@@ -1884,17 +1881,17 @@ static void smsc_ircc_sir_write_wakeup(struct smsc_ircc_cb *self)
 static int smsc_ircc_sir_write(int iobase, int fifo_size, __u8 *buf, int len)
 {
         int actual = 0;
-        
+
         /* Tx FIFO should be empty! */
-        if (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) {
+        if (!(inb(iobase + UART_LSR) & UART_LSR_THRE)) {
                 IRDA_WARNING("%s(), failed, fifo not empty!\n", __FUNCTION__);
                 return 0;
         }
-        
+
         /* Fill FIFO with current frame */
-        while ((fifo_size-- > 0) && (actual < len)) {
+        while (fifo_size-- > 0 && actual < len) {
                 /* Transmit next byte */
-                outb(buf[actual], iobase+UART_TX);
+                outb(buf[actual], iobase + UART_TX);
                 actual++;
         }
         return actual;
@@ -1921,20 +1918,21 @@ static int smsc_ircc_is_receiving(struct smsc_ircc_cb *self)
 static void smsc_ircc_probe_transceiver(struct smsc_ircc_cb *self)
 {
         unsigned int    i;
-        
+
         IRDA_ASSERT(self != NULL, return;);
-        
-        for(i=0; smsc_transceivers[i].name!=NULL; i++) 
-                if((*smsc_transceivers[i].probe)(self->io.fir_base)) {
+
+        for (i = 0; smsc_transceivers[i].name != NULL; i++)
+                if (smsc_transceivers[i].probe(self->io.fir_base)) {
                         IRDA_MESSAGE(" %s transceiver found\n",
                                      smsc_transceivers[i].name);
-                        self->transceiver= i+1;
+                        self->transceiver= i + 1;
                         return;
                 }
+
         IRDA_MESSAGE("No transceiver found. Defaulting to %s\n",
                      smsc_transceivers[SMSC_IRCC2_C_DEFAULT_TRANSCEIVER].name);
-                        
-        self->transceiver= SMSC_IRCC2_C_DEFAULT_TRANSCEIVER;
+
+        self->transceiver = SMSC_IRCC2_C_DEFAULT_TRANSCEIVER;
 }
 
 
@@ -1947,9 +1945,10 @@ static void smsc_ircc_probe_transceiver(struct smsc_ircc_cb *self)
 static void smsc_ircc_set_transceiver_for_speed(struct smsc_ircc_cb *self, u32 speed)
 {
         unsigned int trx;
-        
+
         trx = self->transceiver;
-        if(trx>0) (*smsc_transceivers[trx-1].set_for_speed)(self->io.fir_base, speed);
+        if (trx > 0)
+                smsc_transceivers[trx - 1].set_for_speed(self->io.fir_base, speed);
 }
 
 /*
@@ -1977,16 +1976,14 @@ static void smsc_ircc_set_transceiver_for_speed(struct smsc_ircc_cb *self, u32 s
 
 static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self)
 {
-        int iobase;
+        int iobase = self->io.sir_base;
         int count = SMSC_IRCC2_HW_TRANSMITTER_TIMEOUT_US;
-        
-        iobase = self->io.sir_base;
-        
+
         /* Calibrated busy loop */
-        while((count-- > 0) && !(inb(iobase+UART_LSR) & UART_LSR_TEMT))
+        while (count-- > 0 && !(inb(iobase + UART_LSR) & UART_LSR_TEMT))
                 udelay(1);
 
-        if(count == 0)
+        if (count == 0)
                 IRDA_DEBUG(0, "%s(): stuck transmitter\n", __FUNCTION__);
 }
 
@@ -1998,40 +1995,42 @@ static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self)
 
 static int __init smsc_ircc_look_for_chips(void)
 {
-        smsc_chip_address_t *address;
-        char    *type;
+        struct smsc_chip_address *address;
+        char *type;
         unsigned int cfg_base, found;
-        
+
         found = 0;
         address = possible_addresses;
-        
-        while(address->cfg_base){
+
+        while (address->cfg_base) {
                 cfg_base = address->cfg_base;
-                
+
                 /*printk(KERN_WARNING "%s(): probing: 0x%02x for: 0x%02x\n", __FUNCTION__, cfg_base, address->type);*/
-                
-                if( address->type & SMSCSIO_TYPE_FDC){
+
+                if (address->type & SMSCSIO_TYPE_FDC) {
                         type = "FDC";
-                        if((address->type) & SMSCSIO_TYPE_FLAT) {
-                                if(!smsc_superio_flat(fdc_chips_flat,cfg_base, type)) found++;
-                        }
-                        if((address->type) & SMSCSIO_TYPE_PAGED) {
-                                if(!smsc_superio_paged(fdc_chips_paged,cfg_base, type)) found++;                
-                        }                       
+                        if (address->type & SMSCSIO_TYPE_FLAT)
+                                if (!smsc_superio_flat(fdc_chips_flat, cfg_base, type))
+                                        found++;
+
+                        if (address->type & SMSCSIO_TYPE_PAGED)
+                                if (!smsc_superio_paged(fdc_chips_paged, cfg_base, type))
+                                        found++;
                 }
-                if( address->type & SMSCSIO_TYPE_LPC){
+                if (address->type & SMSCSIO_TYPE_LPC) {
                         type = "LPC";
-                        if((address->type) & SMSCSIO_TYPE_FLAT) {
-                                if(!smsc_superio_flat(lpc_chips_flat,cfg_base,type)) found++;
-                        }
-                        if((address->type) & SMSCSIO_TYPE_PAGED) {
-                                if(!smsc_superio_paged(lpc_chips_paged,cfg_base,"LPC")) found++;                
-                        }                       
+                        if (address->type & SMSCSIO_TYPE_FLAT)
+                                if (!smsc_superio_flat(lpc_chips_flat, cfg_base, type))
+                                        found++;
+
+                        if (address->type & SMSCSIO_TYPE_PAGED)
+                                if (!smsc_superio_paged(lpc_chips_paged, cfg_base, type))
+                                        found++;
                 }
                 address++;
         }
         return found;
-} 
+}
 
 /*
  * Function smsc_superio_flat (chip, base, type)
@@ -2039,7 +2038,7 @@ static int __init smsc_ircc_look_for_chips(void)
  *    Try to get configuration of a smc SuperIO chip with flat register model
  *
  */
-static int __init smsc_superio_flat(const smsc_chip_t *chips, unsigned short cfgbase, char *type)
+static int __init smsc_superio_flat(const struct smsc_chip *chips, unsigned short cfgbase, char *type)
 {
         unsigned short firbase, sirbase;
         u8 mode, dma, irq;
@@ -2047,39 +2046,37 @@ static int __init smsc_superio_flat(const smsc_chip_t *chips, unsigned short cfg
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
-        if (smsc_ircc_probe(cfgbase, SMSCSIOFLAT_DEVICEID_REG, chips, type)==NULL)
+        if (smsc_ircc_probe(cfgbase, SMSCSIOFLAT_DEVICEID_REG, chips, type) == NULL)
                 return ret;
 
         outb(SMSCSIOFLAT_UARTMODE0C_REG, cfgbase);
-        mode = inb(cfgbase+1);
-        
+        mode = inb(cfgbase + 1);
+
         /*printk(KERN_WARNING "%s(): mode: 0x%02x\n", __FUNCTION__, mode);*/
-        
-        if(!(mode & SMSCSIOFLAT_UART2MODE_VAL_IRDA))
+
+        if (!(mode & SMSCSIOFLAT_UART2MODE_VAL_IRDA))
                 IRDA_WARNING("%s(): IrDA not enabled\n", __FUNCTION__);
 
         outb(SMSCSIOFLAT_UART2BASEADDR_REG, cfgbase);
-        sirbase = inb(cfgbase+1) << 2;
+        sirbase = inb(cfgbase + 1) << 2;
 
-        /* FIR iobase */
+        /* FIR iobase */
         outb(SMSCSIOFLAT_FIRBASEADDR_REG, cfgbase);
-        firbase = inb(cfgbase+1) << 3;
+        firbase = inb(cfgbase + 1) << 3;
 
         /* DMA */
         outb(SMSCSIOFLAT_FIRDMASELECT_REG, cfgbase);
-        dma = inb(cfgbase+1) & SMSCSIOFLAT_FIRDMASELECT_MASK;
-        
+        dma = inb(cfgbase + 1) & SMSCSIOFLAT_FIRDMASELECT_MASK;
+
         /* IRQ */
         outb(SMSCSIOFLAT_UARTIRQSELECT_REG, cfgbase);
-        irq = inb(cfgbase+1) & SMSCSIOFLAT_UART2IRQSELECT_MASK;
+        irq = inb(cfgbase + 1) & SMSCSIOFLAT_UART2IRQSELECT_MASK;
 
         IRDA_MESSAGE("%s(): fir: 0x%02x, sir: 0x%02x, dma: %02d, irq: %d, mode: 0x%02x\n", __FUNCTION__, firbase, sirbase, dma, irq, mode);
 
-        if (firbase) {
-                if (smsc_ircc_open(firbase, sirbase, dma, irq) == 0)
-                        ret=0; 
-        }
-        
+        if (firbase && smsc_ircc_open(firbase, sirbase, dma, irq) == 0)
+                ret = 0;
+
         /* Exit configuration */
         outb(SMSCSIO_CFGEXITKEY, cfgbase);
 
@@ -2092,26 +2089,26 @@ static int __init smsc_superio_flat(const smsc_chip_t *chips, unsigned short cfg
  *    Try  to get configuration of a smc SuperIO chip with paged register model
  *
  */
-static int __init smsc_superio_paged(const smsc_chip_t *chips, unsigned short cfg_base, char *type)
+static int __init smsc_superio_paged(const struct smsc_chip *chips, unsigned short cfg_base, char *type)
 {
         unsigned short fir_io, sir_io;
         int ret = -ENODEV;
-        
+
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
-        if (smsc_ircc_probe(cfg_base,0x20,chips,type)==NULL)
+        if (smsc_ircc_probe(cfg_base, 0x20, chips, type) == NULL)
                 return ret;
-        
+
         /* Select logical device (UART2) */
         outb(0x07, cfg_base);
         outb(0x05, cfg_base + 1);
-                
+
         /* SIR iobase */
         outb(0x60, cfg_base);
-        sir_io  = inb(cfg_base + 1) << 8;
+        sir_io = inb(cfg_base + 1) << 8;
         outb(0x61, cfg_base);
         sir_io |= inb(cfg_base + 1);
-                
+
         /* Read FIR base */
         outb(0x62, cfg_base);
         fir_io = inb(cfg_base + 1) << 8;
@@ -2119,11 +2116,9 @@ static int __init smsc_superio_paged(const smsc_chip_t *chips, unsigned short cf
         fir_io |= inb(cfg_base + 1);
         outb(0x2b, cfg_base); /* ??? */
 
-        if (fir_io) {
-                if (smsc_ircc_open(fir_io, sir_io, ircc_dma, ircc_irq) == 0)
-                        ret=0; 
-        }
-        
+        if (fir_io && smsc_ircc_open(fir_io, sir_io, ircc_dma, ircc_irq) == 0)
+                ret = 0;
+
         /* Exit configuration */
         outb(SMSCSIO_CFGEXITKEY, cfg_base);
 
@@ -2131,21 +2126,17 @@ static int __init smsc_superio_paged(const smsc_chip_t *chips, unsigned short cf
 }
 
 
-static int __init smsc_access(unsigned short cfg_base,unsigned char reg)
+static int __init smsc_access(unsigned short cfg_base, unsigned char reg)
 {
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
         outb(reg, cfg_base);
-
-        if (inb(cfg_base)!=reg)
-                return -1;
-
-        return 0;
+        return inb(cfg_base) != reg ? -1 : 0;
 }
 
-static const smsc_chip_t * __init smsc_ircc_probe(unsigned short cfg_base,u8 reg,const smsc_chip_t *chip,char *type)
+static const struct smsc_chip * __init smsc_ircc_probe(unsigned short cfg_base, u8 reg, const struct smsc_chip *chip, char *type)
 {
-        u8 devid,xdevid,rev; 
+        u8 devid, xdevid, rev;
 
         IRDA_DEBUG(1, "%s\n", __FUNCTION__);
 
@@ -2158,7 +2149,7 @@ static const smsc_chip_t * __init smsc_ircc_probe(unsigned short cfg_base,u8 reg
 
         outb(reg, cfg_base);
 
-        xdevid=inb(cfg_base+1);
+        xdevid = inb(cfg_base + 1);
 
         /* Enter configuration */
 
@@ -2168,51 +2159,49 @@ static const smsc_chip_t * __init smsc_ircc_probe(unsigned short cfg_base,u8 reg
         if (smsc_access(cfg_base,0x55)) /* send second key and check */
                 return NULL;
         #endif
-        
+
         /* probe device ID */
 
-        if (smsc_access(cfg_base,reg))
+        if (smsc_access(cfg_base, reg))
                 return NULL;
 
-        devid=inb(cfg_base+1);
-        
-        if (devid==0)                   /* typical value for unused port */
-                return NULL;
+        devid = inb(cfg_base + 1);
 
-        if (devid==0xff)                /* typical value for unused port */
+        if (devid == 0 || devid == 0xff)        /* typical values for unused port */
                 return NULL;
 
         /* probe revision ID */
 
-        if (smsc_access(cfg_base,reg+1))
+        if (smsc_access(cfg_base, reg + 1))
                 return NULL;
 
-        rev=inb(cfg_base+1);
+        rev = inb(cfg_base + 1);
 
-        if (rev>=128)                   /* i think this will make no sense */
+        if (rev >= 128)                 /* i think this will make no sense */
                 return NULL;
 
-        if (devid==xdevid)              /* protection against false positives */        
+        if (devid == xdevid)            /* protection against false positives */
                 return NULL;
 
         /* Check for expected device ID; are there others? */
 
-        while(chip->devid!=devid) {
+        while (chip->devid != devid) {
 
                 chip++;
 
-                if (chip->name==NULL)
+                if (chip->name == NULL)
                         return NULL;
         }
 
-        IRDA_MESSAGE("found SMC SuperIO Chip (devid=0x%02x rev=%02X base=0x%04x): %s%s\n",devid,rev,cfg_base,type,chip->name);
+        IRDA_MESSAGE("found SMC SuperIO Chip (devid=0x%02x rev=%02X base=0x%04x): %s%s\n",
+                     devid, rev, cfg_base, type, chip->name);
 
-        if (chip->rev>rev){
-                IRDA_MESSAGE("Revision higher than expected\n");        
+        if (chip->rev > rev) {
+                IRDA_MESSAGE("Revision higher than expected\n");
                 return NULL;
         }
-        
-        if (chip->flags&NoIRDA)
+
+        if (chip->flags & NoIRDA)
                 IRDA_MESSAGE("chipset does not support IRDA\n");
 
         return chip;
@@ -2226,8 +2215,8 @@ static int __init smsc_superio_fdc(unsigned short cfg_base)
                 IRDA_WARNING("%s: can't get cfg_base of 0x%03x\n",
                              __FUNCTION__, cfg_base);
         } else {
-                if (!smsc_superio_flat(fdc_chips_flat,cfg_base,"FDC")
-                    ||!smsc_superio_paged(fdc_chips_paged,cfg_base,"FDC"))
+                if (!smsc_superio_flat(fdc_chips_flat, cfg_base, "FDC") ||
+                    !smsc_superio_paged(fdc_chips_paged, cfg_base, "FDC"))
                         ret =  0;
 
                 release_region(cfg_base, 2);
@@ -2244,9 +2233,10 @@ static int __init smsc_superio_lpc(unsigned short cfg_base)
                 IRDA_WARNING("%s: can't get cfg_base of 0x%03x\n",
                              __FUNCTION__, cfg_base);
         } else {
-                if (!smsc_superio_flat(lpc_chips_flat,cfg_base,"LPC")
-                    ||!smsc_superio_paged(lpc_chips_paged,cfg_base,"LPC"))
+                if (!smsc_superio_flat(lpc_chips_flat, cfg_base, "LPC") ||
+                    !smsc_superio_paged(lpc_chips_paged, cfg_base, "LPC"))
                         ret = 0;
+
                 release_region(cfg_base, 2);
         }
         return ret;
@@ -2269,18 +2259,23 @@ static int __init smsc_superio_lpc(unsigned short cfg_base)
 static void smsc_ircc_set_transceiver_smsc_ircc_atc(int fir_base, u32 speed)
 {
         unsigned long jiffies_now, jiffies_timeout;
-        u8      val;
-        
-        jiffies_now= jiffies;
-        jiffies_timeout= jiffies+SMSC_IRCC2_ATC_PROGRAMMING_TIMEOUT_JIFFIES;
-        
+        u8 val;
+
+        jiffies_now = jiffies;
+        jiffies_timeout = jiffies + SMSC_IRCC2_ATC_PROGRAMMING_TIMEOUT_JIFFIES;
+
         /* ATC */
         register_bank(fir_base, 4);
-        outb((inb(fir_base+IRCC_ATC) & IRCC_ATC_MASK) |IRCC_ATC_nPROGREADY|IRCC_ATC_ENABLE, fir_base+IRCC_ATC);
-        while((val=(inb(fir_base+IRCC_ATC) & IRCC_ATC_nPROGREADY)) && !time_after(jiffies, jiffies_timeout));
-        if(val)
+        outb((inb(fir_base + IRCC_ATC) & IRCC_ATC_MASK) | IRCC_ATC_nPROGREADY|IRCC_ATC_ENABLE,
+             fir_base + IRCC_ATC);
+
+        while ((val = (inb(fir_base + IRCC_ATC) & IRCC_ATC_nPROGREADY)) &&
+                !time_after(jiffies, jiffies_timeout))
+                /* empty */;
+
+        if (val)
                 IRDA_WARNING("%s(): ATC: 0x%02x\n", __FUNCTION__,
-                             inb(fir_base+IRCC_ATC));
+                             inb(fir_base + IRCC_ATC));
 }
 
 /*
@@ -2298,34 +2293,32 @@ static int smsc_ircc_probe_transceiver_smsc_ircc_atc(int fir_base)
 /*
  * Function smsc_ircc_set_transceiver_smsc_ircc_fast_pin_select(self, speed)
  *
- *    Set transceiver 
+ *    Set transceiver
  *
  */
 
 static void smsc_ircc_set_transceiver_smsc_ircc_fast_pin_select(int fir_base, u32 speed)
 {
-        u8      fast_mode;
-        
-        switch(speed)
-        {
-                default:
-                case 576000 :
-                fast_mode = 0; 
+        u8 fast_mode;
+
+        switch (speed) {
+        default:
+        case 576000 :
+                fast_mode = 0;
                 break;
-                case 1152000 :
-                case 4000000 :
+        case 1152000 :
+        case 4000000 :
                 fast_mode = IRCC_LCR_A_FAST;
                 break;
-                
         }
         register_bank(fir_base, 0);
-        outb((inb(fir_base+IRCC_LCR_A) &  0xbf) | fast_mode, fir_base+IRCC_LCR_A);
+        outb((inb(fir_base + IRCC_LCR_A) & 0xbf) | fast_mode, fir_base + IRCC_LCR_A);
 }
 
 /*
  * Function smsc_ircc_probe_transceiver_smsc_ircc_fast_pin_select(fir_base)
  *
- *    Probe transceiver 
+ *    Probe transceiver
  *
  */
 
@@ -2337,35 +2330,34 @@ static int smsc_ircc_probe_transceiver_smsc_ircc_fast_pin_select(int fir_base)
 /*
  * Function smsc_ircc_set_transceiver_toshiba_sat1800(fir_base, speed)
  *
- *    Set transceiver 
+ *    Set transceiver
  *
  */
 
 static void smsc_ircc_set_transceiver_toshiba_sat1800(int fir_base, u32 speed)
 {
-        u8      fast_mode;
-        
-        switch(speed)
-        {
-                default:
-                case 576000 :
-                fast_mode = 0; 
+        u8 fast_mode;
+
+        switch (speed) {
+        default:
+        case 576000 :
+                fast_mode = 0;
                 break;
-                case 1152000 :
-                case 4000000 :
+        case 1152000 :
+        case 4000000 :
                 fast_mode = /*IRCC_LCR_A_FAST |*/ IRCC_LCR_A_GP_DATA;
                 break;
-                
+
         }
         /* This causes an interrupt */
         register_bank(fir_base, 0);
-        outb((inb(fir_base+IRCC_LCR_A) &  0xbf) | fast_mode, fir_base+IRCC_LCR_A);
+        outb((inb(fir_base + IRCC_LCR_A) &  0xbf) | fast_mode, fir_base + IRCC_LCR_A);
 }
 
 /*
  * Function smsc_ircc_probe_transceiver_toshiba_sat1800(fir_base)
  *
- *    Probe transceiver 
+ *    Probe transceiver
  *
  */
 
@@ -2377,20 +2369,3 @@ static int smsc_ircc_probe_transceiver_toshiba_sat1800(int fir_base)
 
 module_init(smsc_ircc_init);
 module_exit(smsc_ircc_cleanup);
-
-MODULE_AUTHOR("Daniele Peri <peri@csai.unipa.it>");
-MODULE_DESCRIPTION("SMC IrCC SIR/FIR controller driver");
-MODULE_LICENSE("GPL");
-
-module_param(ircc_dma, int, 0);
-MODULE_PARM_DESC(ircc_dma, "DMA channel");
-module_param(ircc_irq, int, 0);
-MODULE_PARM_DESC(ircc_irq, "IRQ line");
-module_param(ircc_fir, int, 0);
-MODULE_PARM_DESC(ircc_fir, "FIR Base Address");
-module_param(ircc_sir, int, 0);
-MODULE_PARM_DESC(ircc_sir, "SIR Base Address");
-module_param(ircc_cfg, int, 0);
-MODULE_PARM_DESC(ircc_cfg, "Configuration register base address");
-module_param(ircc_transceiver, int, 0);
-MODULE_PARM_DESC(ircc_transceiver, "Transceiver type");
diff --git a/drivers/net/irda/smsc-ircc2.h b/drivers/net/irda/smsc-ircc2.h
index 458611cc0d40..0c36286d87f7 100644
--- a/drivers/net/irda/smsc-ircc2.h
+++ b/drivers/net/irda/smsc-ircc2.h
@@ -1,5 +1,5 @@
 /*********************************************************************
- * $Id: smsc-ircc2.h,v 1.12.2.1 2002/10/27 10:52:37 dip Exp $               
+ * $Id: smsc-ircc2.h,v 1.12.2.1 2002/10/27 10:52:37 dip Exp $
  *
  * Description:   Definitions for the SMC IrCC chipset
  * Status:        Experimental.
@@ -9,25 +9,25 @@
  *     All Rights Reserved.
  *
  * Based on smc-ircc.h:
- * 
+ *
  *     Copyright (c) 1999-2000, Dag Brattli <dagb@cs.uit.no>
  *     Copyright (c) 1998-1999, Thomas Davis (tadavis@jps.net>
  *     All Rights Reserved
  *
- *      
- *     This program is free software; you can redistribute it and/or 
- *     modify it under the terms of the GNU General Public License as 
- *     published by the Free Software Foundation; either version 2 of 
+ *
+ *     This program is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License as
+ *     published by the Free Software Foundation; either version 2 of
  *     the License, or (at your option) any later version.
- * 
+ *
  *     This program is distributed in the hope that it will be useful,
  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  *     GNU General Public License for more details.
- * 
- *     You should have received a copy of the GNU General Public License 
- *     along with this program; if not, write to the Free Software 
- *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program; if not, write to the Free Software
+ *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  *     MA 02111-1307 USA
  *
  ********************************************************************/
@@ -112,10 +112,10 @@
 
 #define   IRCC_CFGA_COM                         0x00
 #define         IRCC_SCE_CFGA_BLOCK_CTRL_BITS_MASK      0x87
-#define         IRCC_CFGA_IRDA_SIR_A    0x08
-#define         IRCC_CFGA_ASK_SIR               0x10
-#define         IRCC_CFGA_IRDA_SIR_B    0x18
-#define         IRCC_CFGA_IRDA_HDLC             0x20
+#define         IRCC_CFGA_IRDA_SIR_A    0x08
+#define         IRCC_CFGA_ASK_SIR               0x10
+#define         IRCC_CFGA_IRDA_SIR_B    0x18
+#define         IRCC_CFGA_IRDA_HDLC             0x20
 #define         IRCC_CFGA_IRDA_4PPM             0x28
 #define         IRCC_CFGA_CONSUMER              0x30
 #define         IRCC_CFGA_RAW_IR                0x38
@@ -130,7 +130,7 @@
 #define IRCC_CFGB_LPBCK_TX_CRC     0x10
 #define IRCC_CFGB_NOWAIT           0x08
 #define IRCC_CFGB_STRING_MOVE      0x04
-#define IRCC_CFGB_DMA_BURST        0x02
+#define IRCC_CFGB_DMA_BURST        0x02
 #define IRCC_CFGB_DMA_ENABLE       0x01
 
 #define IRCC_CFGB_MUX_COM          0x00
@@ -141,11 +141,11 @@
 /* Register block 3 - Identification Registers! */
 #define IRCC_ID_HIGH               0x00   /* 0x10 */
 #define IRCC_ID_LOW                0x01   /* 0xB8 */
-#define IRCC_CHIP_ID               0x02   /* 0xF1 */
+#define IRCC_CHIP_ID               0x02   /* 0xF1 */
 #define IRCC_VERSION               0x03   /* 0x01 */
 #define IRCC_INTERFACE             0x04   /* low 4 = DMA, high 4 = IRQ */
-#define         IRCC_INTERFACE_DMA_MASK 0x0F   /* low 4 = DMA, high 4 = IRQ */
-#define         IRCC_INTERFACE_IRQ_MASK 0xF0   /* low 4 = DMA, high 4 = IRQ */
+#define         IRCC_INTERFACE_DMA_MASK 0x0F   /* low 4 = DMA, high 4 = IRQ */
+#define         IRCC_INTERFACE_IRQ_MASK 0xF0   /* low 4 = DMA, high 4 = IRQ */
 
 /* Register block 4 - IrDA */
 #define IRCC_CONTROL               0x00
@@ -163,10 +163,10 @@
 
 /* Register block 5 - IrDA */
 #define IRCC_ATC                                        0x00
-#define         IRCC_ATC_nPROGREADY             0x80
-#define         IRCC_ATC_SPEED                  0x40
-#define         IRCC_ATC_ENABLE                 0x20
-#define         IRCC_ATC_MASK                   0xE0
+#define         IRCC_ATC_nPROGREADY             0x80
+#define         IRCC_ATC_SPEED                  0x40
+#define         IRCC_ATC_ENABLE                 0x20
+#define         IRCC_ATC_MASK                   0xE0
 
 
 #define IRCC_IRHALFDUPLEX_TIMEOUT       0x01
@@ -178,8 +178,8 @@
  */
 
 #define SMSC_IRCC2_MAX_SIR_SPEED                115200
-#define SMSC_IRCC2_FIR_CHIP_IO_EXTENT   8
-#define SMSC_IRCC2_SIR_CHIP_IO_EXTENT   8
+#define SMSC_IRCC2_FIR_CHIP_IO_EXTENT   8
+#define SMSC_IRCC2_SIR_CHIP_IO_EXTENT   8
 #define SMSC_IRCC2_FIFO_SIZE                    16
 #define SMSC_IRCC2_FIFO_THRESHOLD               64
 /* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index dc5d089bf184..3d56cf5a4e23 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -4,6 +4,7 @@
  * Copyright (C) 2001 Kyle A. Lucke (klucke@us.ibm.com), IBM Corp.
  * Substantially cleaned up by:
  * Copyright (C) 2003 David Gibson <dwg@au1.ibm.com>, IBM Corporation.
+ * Copyright (C) 2004-2005 Michael Ellerman, IBM Corporation.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
diff --git a/drivers/net/s2io-regs.h b/drivers/net/s2io-regs.h
index 2234a8f05eb2..7cefe5507b9e 100644
--- a/drivers/net/s2io-regs.h
+++ b/drivers/net/s2io-regs.h
@@ -1,5 +1,5 @@
 /************************************************************************
- * regs.h: A Linux PCI-X Ethernet driver for S2IO 10GbE Server NIC
+ * regs.h: A Linux PCI-X Ethernet driver for Neterion 10GbE Server NIC
  * Copyright(c) 2002-2005 Neterion Inc.
 
  * This software may be used and distributed according to the terms of
@@ -713,13 +713,16 @@ typedef struct _XENA_dev_config {
         u64 mc_err_reg;
 #define MC_ERR_REG_ECC_DB_ERR_L            BIT(14)
 #define MC_ERR_REG_ECC_DB_ERR_U            BIT(15)
+#define MC_ERR_REG_MIRI_ECC_DB_ERR_0       BIT(18)
+#define MC_ERR_REG_MIRI_ECC_DB_ERR_1       BIT(20)
 #define MC_ERR_REG_MIRI_CRI_ERR_0          BIT(22)
 #define MC_ERR_REG_MIRI_CRI_ERR_1          BIT(23)
 #define MC_ERR_REG_SM_ERR                  BIT(31)
-#define MC_ERR_REG_ECC_ALL_SNG             (BIT(6) | \
-                                        BIT(7) | BIT(17) | BIT(19))
-#define MC_ERR_REG_ECC_ALL_DBL             (BIT(14) | \
-                                        BIT(15) | BIT(18) | BIT(20))
+#define MC_ERR_REG_ECC_ALL_SNG             (BIT(2) | BIT(3) | BIT(4) | BIT(5) |\
+                                            BIT(6) | BIT(7) | BIT(17) | BIT(19))
+#define MC_ERR_REG_ECC_ALL_DBL             (BIT(10) | BIT(11) | BIT(12) |\
+                                            BIT(13) | BIT(14) | BIT(15) |\
+                                            BIT(18) | BIT(20))
         u64 mc_err_mask;
         u64 mc_err_alarm;
 
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 5dda043bd9d7..c829e6a2e8a6 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -1,5 +1,5 @@
 /************************************************************************
- * s2io.c: A Linux PCI-X Ethernet driver for S2IO 10GbE Server NIC
+ * s2io.c: A Linux PCI-X Ethernet driver for Neterion 10GbE Server NIC
  * Copyright(c) 2002-2005 Neterion Inc.
 
  * This software may be used and distributed according to the terms of
@@ -28,7 +28,7 @@
  * explaination of all the variables.
  * rx_ring_num : This can be used to program the number of receive rings used
  * in the driver.
- * rx_ring_len: This defines the number of descriptors each ring can have. This
+ * rx_ring_sz: This defines the number of descriptors each ring can have. This
  * is also an array of size 8.
  * tx_fifo_num: This defines the number of Tx FIFOs thats used int the driver.
  * tx_fifo_len: This too is an array of 8. Each element defines the number of
@@ -67,7 +67,7 @@
 
 /* S2io Driver name & version. */
 static char s2io_driver_name[] = "Neterion";
-static char s2io_driver_version[] = "Version 2.0.3.1";
+static char s2io_driver_version[] = "Version 2.0.8.1";
 
 static inline int RXD_IS_UP2DT(RxD_t *rxdp)
 {
@@ -354,7 +354,7 @@ static int init_shared_mem(struct s2io_nic *nic)
         int lst_size, lst_per_page;
         struct net_device *dev = nic->dev;
 #ifdef CONFIG_2BUFF_MODE
-        u64 tmp;
+        unsigned long tmp;
         buffAdd_t *ba;
 #endif
 
@@ -404,7 +404,7 @@ static int init_shared_mem(struct s2io_nic *nic)
                     config->tx_cfg[i].fifo_len - 1;
                 mac_control->fifos[i].fifo_no = i;
                 mac_control->fifos[i].nic = nic;
-                mac_control->fifos[i].max_txds = MAX_SKB_FRAGS;
+                mac_control->fifos[i].max_txds = MAX_SKB_FRAGS + 1;
 
                 for (j = 0; j < page_num; j++) {
                         int k = 0;
@@ -418,6 +418,26 @@ static int init_shared_mem(struct s2io_nic *nic)
                                 DBG_PRINT(ERR_DBG, "failed for TxDL\n");
                                 return -ENOMEM;
                         }
+                        /* If we got a zero DMA address(can happen on
+                         * certain platforms like PPC), reallocate.
+                         * Store virtual address of page we don't want,
+                         * to be freed later.
+                         */
+                        if (!tmp_p) {
+                                mac_control->zerodma_virt_addr = tmp_v;
+                                DBG_PRINT(INIT_DBG, 
+                                "%s: Zero DMA address for TxDL. ", dev->name);
+                                DBG_PRINT(INIT_DBG, 
+                                "Virtual address %llx\n", (u64)tmp_v);
+                                tmp_v = pci_alloc_consistent(nic->pdev,
+                                                     PAGE_SIZE, &tmp_p);
+                                if (!tmp_v) {
+                                        DBG_PRINT(ERR_DBG,
+                                          "pci_alloc_consistent ");
+                                        DBG_PRINT(ERR_DBG, "failed for TxDL\n");
+                                        return -ENOMEM;
+                                }
+                        }
                         while (k < lst_per_page) {
                                 int l = (j * lst_per_page) + k;
                                 if (l == config->tx_cfg[i].fifo_len)
@@ -542,18 +562,18 @@ static int init_shared_mem(struct s2io_nic *nic)
                                     (BUF0_LEN + ALIGN_SIZE, GFP_KERNEL);
                                 if (!ba->ba_0_org)
                                         return -ENOMEM;
-                                tmp = (u64) ba->ba_0_org;
+                                tmp = (unsigned long) ba->ba_0_org;
                                 tmp += ALIGN_SIZE;
-                                tmp &= ~((u64) ALIGN_SIZE);
+                                tmp &= ~((unsigned long) ALIGN_SIZE);
                                 ba->ba_0 = (void *) tmp;
 
                                 ba->ba_1_org = (void *) kmalloc
                                     (BUF1_LEN + ALIGN_SIZE, GFP_KERNEL);
                                 if (!ba->ba_1_org)
                                         return -ENOMEM;
-                                tmp = (u64) ba->ba_1_org;
+                                tmp = (unsigned long) ba->ba_1_org;
                                 tmp += ALIGN_SIZE;
-                                tmp &= ~((u64) ALIGN_SIZE);
+                                tmp &= ~((unsigned long) ALIGN_SIZE);
                                 ba->ba_1 = (void *) tmp;
                                 k++;
                         }
@@ -600,7 +620,7 @@ static void free_shared_mem(struct s2io_nic *nic)
         mac_info_t *mac_control;
         struct config_param *config;
         int lst_size, lst_per_page;
-
+        struct net_device *dev = nic->dev;
 
         if (!nic)
                 return;
@@ -616,9 +636,10 @@ static void free_shared_mem(struct s2io_nic *nic)
                                                 lst_per_page);
                 for (j = 0; j < page_num; j++) {
                         int mem_blks = (j * lst_per_page);
-                        if ((!mac_control->fifos[i].list_info) ||
-                                (!mac_control->fifos[i].list_info[mem_blks].
-                                 list_virt_addr))
+                        if (!mac_control->fifos[i].list_info)
+                                return; 
+                        if (!mac_control->fifos[i].list_info[mem_blks].
+                                 list_virt_addr)
                                 break;
                         pci_free_consistent(nic->pdev, PAGE_SIZE,
                                             mac_control->fifos[i].
@@ -628,6 +649,18 @@ static void free_shared_mem(struct s2io_nic *nic)
                                             list_info[mem_blks].
                                             list_phy_addr);
                 }
+                /* If we got a zero DMA address during allocation,
+                 * free the page now
+                 */
+                if (mac_control->zerodma_virt_addr) {
+                        pci_free_consistent(nic->pdev, PAGE_SIZE,
+                                            mac_control->zerodma_virt_addr,
+                                            (dma_addr_t)0);
+                        DBG_PRINT(INIT_DBG, 
+                        "%s: Freeing TxDL with zero DMA addr. ", dev->name);
+                        DBG_PRINT(INIT_DBG, "Virtual address %llx\n",
+                        (u64)(mac_control->zerodma_virt_addr));
+                }
                 kfree(mac_control->fifos[i].list_info);
         }
 
@@ -2479,9 +2512,10 @@ static void rx_intr_handler(ring_info_t *ring_data)
 #endif
         spin_lock(&nic->rx_lock);
         if (atomic_read(&nic->card_state) == CARD_DOWN) {
-                DBG_PRINT(ERR_DBG, "%s: %s going down for reset\n",
+                DBG_PRINT(INTR_DBG, "%s: %s going down for reset\n",
                           __FUNCTION__, dev->name);
                 spin_unlock(&nic->rx_lock);
+                return;
         }
 
         get_info = ring_data->rx_curr_get_info;
@@ -2596,8 +2630,14 @@ static void tx_intr_handler(fifo_info_t *fifo_data)
                 if (txdlp->Control_1 & TXD_T_CODE) {
                         unsigned long long err;
                         err = txdlp->Control_1 & TXD_T_CODE;
-                        DBG_PRINT(ERR_DBG, "***TxD error %llx\n",
-                                  err);
+                        if ((err >> 48) == 0xA) {
+                                DBG_PRINT(TX_DBG, "TxD returned due \
+                                                to loss of link\n");
+                        }
+                        else {
+                                DBG_PRINT(ERR_DBG, "***TxD error \
+                                                %llx\n", err);
+                        }
                 }
 
                 skb = (struct sk_buff *) ((unsigned long)
@@ -2689,12 +2729,16 @@ static void alarm_intr_handler(struct s2io_nic *nic)
                 if (val64 & MC_ERR_REG_ECC_ALL_DBL) {
                         nic->mac_control.stats_info->sw_stat.
                                 double_ecc_errs++;
-                        DBG_PRINT(ERR_DBG, "%s: Device indicates ",
+                        DBG_PRINT(INIT_DBG, "%s: Device indicates ",
                                   dev->name);
-                        DBG_PRINT(ERR_DBG, "double ECC error!!\n");
+                        DBG_PRINT(INIT_DBG, "double ECC error!!\n");
                         if (nic->device_type != XFRAME_II_DEVICE) {
-                                netif_stop_queue(dev);
-                                schedule_work(&nic->rst_timer_task);
+                                /* Reset XframeI only if critical error */
+                                if (val64 & (MC_ERR_REG_MIRI_ECC_DB_ERR_0 |
+                                             MC_ERR_REG_MIRI_ECC_DB_ERR_1)) {
+                                        netif_stop_queue(dev);
+                                        schedule_work(&nic->rst_timer_task);
+                                }
                         }
                 } else {
                         nic->mac_control.stats_info->sw_stat.
@@ -2706,7 +2750,8 @@ static void alarm_intr_handler(struct s2io_nic *nic)
         val64 = readq(&bar0->serr_source);
         if (val64 & SERR_SOURCE_ANY) {
                 DBG_PRINT(ERR_DBG, "%s: Device indicates ", dev->name);
-                DBG_PRINT(ERR_DBG, "serious error!!\n");
+                DBG_PRINT(ERR_DBG, "serious error %llx!!\n", 
+                          (unsigned long long)val64);
                 netif_stop_queue(dev);
                 schedule_work(&nic->rst_timer_task);
         }
@@ -3130,7 +3175,7 @@ int s2io_xmit(struct sk_buff *skb, struct net_device *dev)
         queue_len = mac_control->fifos[queue].tx_curr_put_info.fifo_len + 1;
         /* Avoid "put" pointer going beyond "get" pointer */
         if (txdp->Host_Control || (((put_off + 1) % queue_len) == get_off)) {
-                DBG_PRINT(ERR_DBG, "Error in xmit, No free TXDs.\n");
+                DBG_PRINT(TX_DBG, "Error in xmit, No free TXDs.\n");
                 netif_stop_queue(dev);
                 dev_kfree_skb(skb);
                 spin_unlock_irqrestore(&sp->tx_lock, flags);
@@ -3528,7 +3573,7 @@ static void s2io_set_multicast(struct net_device *dev)
 
                 val64 = readq(&bar0->mac_cfg);
                 sp->promisc_flg = 1;
-                DBG_PRINT(ERR_DBG, "%s: entered promiscuous mode\n",
+                DBG_PRINT(INFO_DBG, "%s: entered promiscuous mode\n",
                           dev->name);
         } else if (!(dev->flags & IFF_PROMISC) && (sp->promisc_flg)) {
                 /*  Remove the NIC from promiscuous mode */
@@ -3543,7 +3588,7 @@ static void s2io_set_multicast(struct net_device *dev)
 
                 val64 = readq(&bar0->mac_cfg);
                 sp->promisc_flg = 0;
-                DBG_PRINT(ERR_DBG, "%s: left promiscuous mode\n",
+                DBG_PRINT(INFO_DBG, "%s: left promiscuous mode\n",
                           dev->name);
         }
 
@@ -5325,7 +5370,7 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
                         break;
                 }
         }
-        config->max_txds = MAX_SKB_FRAGS;
+        config->max_txds = MAX_SKB_FRAGS + 1;
 
         /* Rx side parameters. */
         if (rx_ring_sz[0] == 0)
@@ -5525,9 +5570,14 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         if (sp->device_type & XFRAME_II_DEVICE) {
                 DBG_PRINT(ERR_DBG, "%s: Neterion Xframe II 10GbE adapter ",
                           dev->name);
-                DBG_PRINT(ERR_DBG, "(rev %d), Driver %s\n",
+                DBG_PRINT(ERR_DBG, "(rev %d), %s",
                                 get_xena_rev_id(sp->pdev),
                                 s2io_driver_version);
+#ifdef CONFIG_2BUFF_MODE
+                DBG_PRINT(ERR_DBG, ", Buffer mode %d",2);
+#endif
+
+                DBG_PRINT(ERR_DBG, "\nCopyright(c) 2002-2005 Neterion Inc.\n");
                 DBG_PRINT(ERR_DBG, "MAC ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n",
                           sp->def_mac_addr[0].mac_addr[0],
                           sp->def_mac_addr[0].mac_addr[1],
@@ -5544,9 +5594,13 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         } else {
                 DBG_PRINT(ERR_DBG, "%s: Neterion Xframe I 10GbE adapter ",
                           dev->name);
-                DBG_PRINT(ERR_DBG, "(rev %d), Driver %s\n",
+                DBG_PRINT(ERR_DBG, "(rev %d), %s",
                                         get_xena_rev_id(sp->pdev),
                                         s2io_driver_version);
+#ifdef CONFIG_2BUFF_MODE
+                DBG_PRINT(ERR_DBG, ", Buffer mode %d",2);
+#endif
+                DBG_PRINT(ERR_DBG, "\nCopyright(c) 2002-2005 Neterion Inc.\n");
                 DBG_PRINT(ERR_DBG, "MAC ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n",
                           sp->def_mac_addr[0].mac_addr[0],
                           sp->def_mac_addr[0].mac_addr[1],
diff --git a/drivers/net/s2io.h b/drivers/net/s2io.h
index bc64d967f080..89151cb52181 100644
--- a/drivers/net/s2io.h
+++ b/drivers/net/s2io.h
@@ -1,5 +1,5 @@
 /************************************************************************
- * s2io.h: A Linux PCI-X Ethernet driver for S2IO 10GbE Server NIC
+ * s2io.h: A Linux PCI-X Ethernet driver for Neterion 10GbE Server NIC
  * Copyright(c) 2002-2005 Neterion Inc.
 
  * This software may be used and distributed according to the terms of
@@ -622,6 +622,9 @@ typedef struct mac_info {
         /* Fifo specific structure */
         fifo_info_t fifos[MAX_TX_FIFOS];
 
+        /* Save virtual address of TxD page with zero DMA addr(if any) */
+        void *zerodma_virt_addr;
+
 /* rx side stuff */
         /* Ring specific structure */
         ring_info_t rings[MAX_RX_RINGS];
diff --git a/drivers/net/smc91x.h b/drivers/net/smc91x.h
index a9b06b8d8e3f..ac9ce6509eee 100644
--- a/drivers/net/smc91x.h
+++ b/drivers/net/smc91x.h
@@ -986,7 +986,7 @@ static const char * chip_ids[ 16 ] =  {
         })
 #endif
 
-#if SMC_CAN_USE_DATACS
+#ifdef SMC_CAN_USE_DATACS
 #define SMC_PUSH_DATA(p, l)                                             \
         if ( lp->datacs ) {                                             \
                 unsigned char *__ptr = (p);                             \
diff --git a/drivers/net/spider_net.c b/drivers/net/spider_net.c
new file mode 100644
index 000000000000..4e19220473d0
--- /dev/null
+++ b/drivers/net/spider_net.c
@@ -0,0 +1,2334 @@
+/*
+ * Network device driver for Cell Processor-Based Blade
+ *
+ * (C) Copyright IBM Corp. 2005
+ *
+ * Authors : Utz Bacher <utz.bacher@de.ibm.com>
+ *           Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/config.h>
+
+#include <linux/compiler.h>
+#include <linux/crc32.h>
+#include <linux/delay.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/firmware.h>
+#include <linux/if_vlan.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/ip.h>
+#include <linux/kernel.h>
+#include <linux/mii.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/device.h>
+#include <linux/pci.h>
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+#include <linux/tcp.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
+#include <asm/bitops.h>
+#include <asm/pci-bridge.h>
+#include <net/checksum.h>
+
+#include "spider_net.h"
+
+MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com> and Jens Osterkamp " \
+              "<Jens.Osterkamp@de.ibm.com>");
+MODULE_DESCRIPTION("Spider Southbridge Gigabit Ethernet driver");
+MODULE_LICENSE("GPL");
+
+static int rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_DEFAULT;
+static int tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_DEFAULT;
+
+module_param(rx_descriptors, int, 0644);
+module_param(tx_descriptors, int, 0644);
+
+MODULE_PARM_DESC(rx_descriptors, "number of descriptors used " \
+                 "in rx chains");
+MODULE_PARM_DESC(tx_descriptors, "number of descriptors used " \
+                 "in tx chain");
+
+char spider_net_driver_name[] = "spidernet";
+
+static struct pci_device_id spider_net_pci_tbl[] = {
+        { PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_SPIDER_NET,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { 0, }
+};
+
+MODULE_DEVICE_TABLE(pci, spider_net_pci_tbl);
+
+/**
+ * spider_net_read_reg - reads an SMMIO register of a card
+ * @card: device structure
+ * @reg: register to read from
+ *
+ * returns the content of the specified SMMIO register.
+ */
+static u32
+spider_net_read_reg(struct spider_net_card *card, u32 reg)
+{
+        u32 value;
+
+        value = readl(card->regs + reg);
+        value = le32_to_cpu(value);
+
+        return value;
+}
+
+/**
+ * spider_net_write_reg - writes to an SMMIO register of a card
+ * @card: device structure
+ * @reg: register to write to
+ * @value: value to write into the specified SMMIO register
+ */
+static void
+spider_net_write_reg(struct spider_net_card *card, u32 reg, u32 value)
+{
+        value = cpu_to_le32(value);
+        writel(value, card->regs + reg);
+}
+
+/**
+ * spider_net_write_reg_sync - writes to an SMMIO register of a card
+ * @card: device structure
+ * @reg: register to write to
+ * @value: value to write into the specified SMMIO register
+ *
+ * Unlike spider_net_write_reg, this will also make sure the
+ * data arrives on the card by reading the reg again.
+ */
+static void
+spider_net_write_reg_sync(struct spider_net_card *card, u32 reg, u32 value)
+{
+        value = cpu_to_le32(value);
+        writel(value, card->regs + reg);
+        (void)readl(card->regs + reg);
+}
+
+/**
+ * spider_net_rx_irq_off - switch off rx irq on this spider card
+ * @card: device structure
+ *
+ * switches off rx irq by masking them out in the GHIINTnMSK register
+ */
+static void
+spider_net_rx_irq_off(struct spider_net_card *card)
+{
+        u32 regvalue;
+        unsigned long flags;
+
+        spin_lock_irqsave(&card->intmask_lock, flags);
+        regvalue = spider_net_read_reg(card, SPIDER_NET_GHIINT0MSK);
+        regvalue &= ~SPIDER_NET_RXINT;
+        spider_net_write_reg_sync(card, SPIDER_NET_GHIINT0MSK, regvalue);
+        spin_unlock_irqrestore(&card->intmask_lock, flags);
+}
+
+/** spider_net_write_phy - write to phy register
+ * @netdev: adapter to be written to
+ * @mii_id: id of MII
+ * @reg: PHY register
+ * @val: value to be written to phy register
+ *
+ * spider_net_write_phy_register writes to an arbitrary PHY
+ * register via the spider GPCWOPCMD register. We assume the queue does
+ * not run full (not more than 15 commands outstanding).
+ **/
+static void
+spider_net_write_phy(struct net_device *netdev, int mii_id,
+                     int reg, int val)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        u32 writevalue;
+
+        writevalue = ((u32)mii_id << 21) |
+                ((u32)reg << 16) | ((u32)val);
+
+        spider_net_write_reg(card, SPIDER_NET_GPCWOPCMD, writevalue);
+}
+
+/** spider_net_read_phy - read from phy register
+ * @netdev: network device to be read from
+ * @mii_id: id of MII
+ * @reg: PHY register
+ *
+ * Returns value read from PHY register
+ *
+ * spider_net_write_phy reads from an arbitrary PHY
+ * register via the spider GPCROPCMD register
+ **/
+static int
+spider_net_read_phy(struct net_device *netdev, int mii_id, int reg)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        u32 readvalue;
+
+        readvalue = ((u32)mii_id << 21) | ((u32)reg << 16);
+        spider_net_write_reg(card, SPIDER_NET_GPCROPCMD, readvalue);
+
+        /* we don't use semaphores to wait for an SPIDER_NET_GPROPCMPINT
+         * interrupt, as we poll for the completion of the read operation
+         * in spider_net_read_phy. Should take about 50 us */
+        do {
+                readvalue = spider_net_read_reg(card, SPIDER_NET_GPCROPCMD);
+        } while (readvalue & SPIDER_NET_GPREXEC);
+
+        readvalue &= SPIDER_NET_GPRDAT_MASK;
+
+        return readvalue;
+}
+
+/**
+ * spider_net_rx_irq_on - switch on rx irq on this spider card
+ * @card: device structure
+ *
+ * switches on rx irq by enabling them in the GHIINTnMSK register
+ */
+static void
+spider_net_rx_irq_on(struct spider_net_card *card)
+{
+        u32 regvalue;
+        unsigned long flags;
+
+        spin_lock_irqsave(&card->intmask_lock, flags);
+        regvalue = spider_net_read_reg(card, SPIDER_NET_GHIINT0MSK);
+        regvalue |= SPIDER_NET_RXINT;
+        spider_net_write_reg_sync(card, SPIDER_NET_GHIINT0MSK, regvalue);
+        spin_unlock_irqrestore(&card->intmask_lock, flags);
+}
+
+/**
+ * spider_net_tx_irq_off - switch off tx irq on this spider card
+ * @card: device structure
+ *
+ * switches off tx irq by masking them out in the GHIINTnMSK register
+ */
+static void
+spider_net_tx_irq_off(struct spider_net_card *card)
+{
+        u32 regvalue;
+        unsigned long flags;
+
+        spin_lock_irqsave(&card->intmask_lock, flags);
+        regvalue = spider_net_read_reg(card, SPIDER_NET_GHIINT0MSK);
+        regvalue &= ~SPIDER_NET_TXINT;
+        spider_net_write_reg_sync(card, SPIDER_NET_GHIINT0MSK, regvalue);
+        spin_unlock_irqrestore(&card->intmask_lock, flags);
+}
+
+/**
+ * spider_net_tx_irq_on - switch on tx irq on this spider card
+ * @card: device structure
+ *
+ * switches on tx irq by enabling them in the GHIINTnMSK register
+ */
+static void
+spider_net_tx_irq_on(struct spider_net_card *card)
+{
+        u32 regvalue;
+        unsigned long flags;
+
+        spin_lock_irqsave(&card->intmask_lock, flags);
+        regvalue = spider_net_read_reg(card, SPIDER_NET_GHIINT0MSK);
+        regvalue |= SPIDER_NET_TXINT;
+        spider_net_write_reg_sync(card, SPIDER_NET_GHIINT0MSK, regvalue);
+        spin_unlock_irqrestore(&card->intmask_lock, flags);
+}
+
+/**
+ * spider_net_set_promisc - sets the unicast address or the promiscuous mode
+ * @card: card structure
+ *
+ * spider_net_set_promisc sets the unicast destination address filter and
+ * thus either allows for non-promisc mode or promisc mode
+ */
+static void
+spider_net_set_promisc(struct spider_net_card *card)
+{
+        u32 macu, macl;
+        struct net_device *netdev = card->netdev;
+
+        if (netdev->flags & IFF_PROMISC) {
+                /* clear destination entry 0 */
+                spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, 0);
+                spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, 0);
+                spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R,
+                                     SPIDER_NET_PROMISC_VALUE);
+        } else {
+                macu = netdev->dev_addr[0];
+                macu <<= 8;
+                macu |= netdev->dev_addr[1];
+                memcpy(&macl, &netdev->dev_addr[2], sizeof(macl));
+
+                macu |= SPIDER_NET_UA_DESCR_VALUE;
+                spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, macu);
+                spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, macl);
+                spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R,
+                                     SPIDER_NET_NONPROMISC_VALUE);
+        }
+}
+
+/**
+ * spider_net_get_mac_address - read mac address from spider card
+ * @card: device structure
+ *
+ * reads MAC address from GMACUNIMACU and GMACUNIMACL registers
+ */
+static int
+spider_net_get_mac_address(struct net_device *netdev)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        u32 macl, macu;
+
+        macl = spider_net_read_reg(card, SPIDER_NET_GMACUNIMACL);
+        macu = spider_net_read_reg(card, SPIDER_NET_GMACUNIMACU);
+
+        netdev->dev_addr[0] = (macu >> 24) & 0xff;
+        netdev->dev_addr[1] = (macu >> 16) & 0xff;
+        netdev->dev_addr[2] = (macu >> 8) & 0xff;
+        netdev->dev_addr[3] = macu & 0xff;
+        netdev->dev_addr[4] = (macl >> 8) & 0xff;
+        netdev->dev_addr[5] = macl & 0xff;
+
+        if (!is_valid_ether_addr(&netdev->dev_addr[0]))
+                return -EINVAL;
+
+        return 0;
+}
+
+/**
+ * spider_net_get_descr_status -- returns the status of a descriptor
+ * @descr: descriptor to look at
+ *
+ * returns the status as in the dmac_cmd_status field of the descriptor
+ */
+static enum spider_net_descr_status
+spider_net_get_descr_status(struct spider_net_descr *descr)
+{
+        u32 cmd_status;
+        rmb();
+        cmd_status = descr->dmac_cmd_status;
+        rmb();
+        cmd_status >>= SPIDER_NET_DESCR_IND_PROC_SHIFT;
+        /* no need to mask out any bits, as cmd_status is 32 bits wide only
+         * (and unsigned) */
+        return cmd_status;
+}
+
+/**
+ * spider_net_set_descr_status -- sets the status of a descriptor
+ * @descr: descriptor to change
+ * @status: status to set in the descriptor
+ *
+ * changes the status to the specified value. Doesn't change other bits
+ * in the status
+ */
+static void
+spider_net_set_descr_status(struct spider_net_descr *descr,
+                            enum spider_net_descr_status status)
+{
+        u32 cmd_status;
+        /* read the status */
+        mb();
+        cmd_status = descr->dmac_cmd_status;
+        /* clean the upper 4 bits */
+        cmd_status &= SPIDER_NET_DESCR_IND_PROC_MASKO;
+        /* add the status to it */
+        cmd_status |= ((u32)status)<<SPIDER_NET_DESCR_IND_PROC_SHIFT;
+        /* and write it back */
+        descr->dmac_cmd_status = cmd_status;
+        wmb();
+}
+
+/**
+ * spider_net_free_chain - free descriptor chain
+ * @card: card structure
+ * @chain: address of chain
+ *
+ */
+static void
+spider_net_free_chain(struct spider_net_card *card,
+                      struct spider_net_descr_chain *chain)
+{
+        struct spider_net_descr *descr;
+
+        for (descr = chain->tail; !descr->bus_addr; descr = descr->next) {
+                pci_unmap_single(card->pdev, descr->bus_addr,
+                                 SPIDER_NET_DESCR_SIZE, PCI_DMA_BIDIRECTIONAL);
+                descr->bus_addr = 0;
+        }
+}
+
+/**
+ * spider_net_init_chain - links descriptor chain
+ * @card: card structure
+ * @chain: address of chain
+ * @start_descr: address of descriptor array
+ * @no: number of descriptors
+ *
+ * we manage a circular list that mirrors the hardware structure,
+ * except that the hardware uses bus addresses.
+ *
+ * returns 0 on success, <0 on failure
+ */
+static int
+spider_net_init_chain(struct spider_net_card *card,
+                       struct spider_net_descr_chain *chain,
+                       struct spider_net_descr *start_descr, int no)
+{
+        int i;
+        struct spider_net_descr *descr;
+
+        spin_lock_init(&card->chain_lock);
+
+        descr = start_descr;
+        memset(descr, 0, sizeof(*descr) * no);
+
+        /* set up the hardware pointers in each descriptor */
+        for (i=0; i<no; i++, descr++) {
+                spider_net_set_descr_status(descr, SPIDER_NET_DESCR_NOT_IN_USE);
+
+                descr->bus_addr =
+                        pci_map_single(card->pdev, descr,
+                                       SPIDER_NET_DESCR_SIZE,
+                                       PCI_DMA_BIDIRECTIONAL);
+
+                if (descr->bus_addr == DMA_ERROR_CODE)
+                        goto iommu_error;
+
+                descr->next = descr + 1;
+                descr->prev = descr - 1;
+
+        }
+        /* do actual circular list */
+        (descr-1)->next = start_descr;
+        start_descr->prev = descr-1;
+
+        descr = start_descr;
+        for (i=0; i < no; i++, descr++) {
+                descr->next_descr_addr = descr->next->bus_addr;
+        }
+
+        chain->head = start_descr;
+        chain->tail = start_descr;
+
+        return 0;
+
+iommu_error:
+        descr = start_descr;
+        for (i=0; i < no; i++, descr++)
+                if (descr->bus_addr)
+                        pci_unmap_single(card->pdev, descr->bus_addr,
+                                         SPIDER_NET_DESCR_SIZE, PCI_DMA_BIDIRECTIONAL);
+        return -ENOMEM;
+}
+
+/**
+ * spider_net_free_rx_chain_contents - frees descr contents in rx chain
+ * @card: card structure
+ *
+ * returns 0 on success, <0 on failure
+ */
+static void
+spider_net_free_rx_chain_contents(struct spider_net_card *card)
+{
+        struct spider_net_descr *descr;
+
+        descr = card->rx_chain.head;
+        while (descr->next != card->rx_chain.head) {
+                if (descr->skb) {
+                        dev_kfree_skb(descr->skb);
+                        pci_unmap_single(card->pdev, descr->buf_addr,
+                                         SPIDER_NET_MAX_MTU,
+                                         PCI_DMA_BIDIRECTIONAL);
+                }
+                descr = descr->next;
+        }
+}
+
+/**
+ * spider_net_prepare_rx_descr - reinitializes a rx descriptor
+ * @card: card structure
+ * @descr: descriptor to re-init
+ *
+ * return 0 on succes, <0 on failure
+ *
+ * allocates a new rx skb, iommu-maps it and attaches it to the descriptor.
+ * Activate the descriptor state-wise
+ */
+static int
+spider_net_prepare_rx_descr(struct spider_net_card *card,
+                            struct spider_net_descr *descr)
+{
+        int error = 0;
+        int offset;
+        int bufsize;
+
+        /* we need to round up the buffer size to a multiple of 128 */
+        bufsize = (SPIDER_NET_MAX_MTU + SPIDER_NET_RXBUF_ALIGN - 1) &
+                (~(SPIDER_NET_RXBUF_ALIGN - 1));
+
+        /* and we need to have it 128 byte aligned, therefore we allocate a
+         * bit more */
+        /* allocate an skb */
+        descr->skb = dev_alloc_skb(bufsize + SPIDER_NET_RXBUF_ALIGN - 1);
+        if (!descr->skb) {
+                if (net_ratelimit())
+                        if (netif_msg_rx_err(card))
+                                pr_err("Not enough memory to allocate "
+                                        "rx buffer\n");
+                return -ENOMEM;
+        }
+        descr->buf_size = bufsize;
+        descr->result_size = 0;
+        descr->valid_size = 0;
+        descr->data_status = 0;
+        descr->data_error = 0;
+
+        offset = ((unsigned long)descr->skb->data) &
+                (SPIDER_NET_RXBUF_ALIGN - 1);
+        if (offset)
+                skb_reserve(descr->skb, SPIDER_NET_RXBUF_ALIGN - offset);
+        /* io-mmu-map the skb */
+        descr->buf_addr = pci_map_single(card->pdev, descr->skb->data,
+                                         SPIDER_NET_MAX_MTU,
+                                         PCI_DMA_BIDIRECTIONAL);
+        if (descr->buf_addr == DMA_ERROR_CODE) {
+                dev_kfree_skb_any(descr->skb);
+                if (netif_msg_rx_err(card))
+                        pr_err("Could not iommu-map rx buffer\n");
+                spider_net_set_descr_status(descr, SPIDER_NET_DESCR_NOT_IN_USE);
+        } else {
+                descr->dmac_cmd_status = SPIDER_NET_DMAC_RX_CARDOWNED;
+        }
+
+        return error;
+}
+
+/**
+ * spider_net_enable_rxctails - sets RX dmac chain tail addresses
+ * @card: card structure
+ *
+ * spider_net_enable_rxctails sets the RX DMAC chain tail adresses in the
+ * chip by writing to the appropriate register. DMA is enabled in
+ * spider_net_enable_rxdmac.
+ */
+static void
+spider_net_enable_rxchtails(struct spider_net_card *card)
+{
+        /* assume chain is aligned correctly */
+        spider_net_write_reg(card, SPIDER_NET_GDADCHA ,
+                             card->rx_chain.tail->bus_addr);
+}
+
+/**
+ * spider_net_enable_rxdmac - enables a receive DMA controller
+ * @card: card structure
+ *
+ * spider_net_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
+ * in the GDADMACCNTR register
+ */
+static void
+spider_net_enable_rxdmac(struct spider_net_card *card)
+{
+        spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR,
+                             SPIDER_NET_DMA_RX_VALUE);
+}
+
+/**
+ * spider_net_refill_rx_chain - refills descriptors/skbs in the rx chains
+ * @card: card structure
+ *
+ * refills descriptors in all chains (last used chain first): allocates skbs
+ * and iommu-maps them.
+ */
+static void
+spider_net_refill_rx_chain(struct spider_net_card *card)
+{
+        struct spider_net_descr_chain *chain;
+        int count = 0;
+        unsigned long flags;
+
+        chain = &card->rx_chain;
+
+        spin_lock_irqsave(&card->chain_lock, flags);
+        while (spider_net_get_descr_status(chain->head) ==
+                                SPIDER_NET_DESCR_NOT_IN_USE) {
+                if (spider_net_prepare_rx_descr(card, chain->head))
+                        break;
+                count++;
+                chain->head = chain->head->next;
+        }
+        spin_unlock_irqrestore(&card->chain_lock, flags);
+
+        /* could be optimized, only do that, if we know the DMA processing
+         * has terminated */
+        if (count)
+                spider_net_enable_rxdmac(card);
+}
+
+/**
+ * spider_net_alloc_rx_skbs - allocates rx skbs in rx descriptor chains
+ * @card: card structure
+ *
+ * returns 0 on success, <0 on failure
+ */
+static int
+spider_net_alloc_rx_skbs(struct spider_net_card *card)
+{
+        int result;
+        struct spider_net_descr_chain *chain;
+
+        result = -ENOMEM;
+
+        chain = &card->rx_chain;
+        /* put at least one buffer into the chain. if this fails,
+         * we've got a problem. if not, spider_net_refill_rx_chain
+         * will do the rest at the end of this function */
+        if (spider_net_prepare_rx_descr(card, chain->head))
+                goto error;
+        else
+                chain->head = chain->head->next;
+
+        /* this will allocate the rest of the rx buffers; if not, it's
+         * business as usual later on */
+        spider_net_refill_rx_chain(card);
+        return 0;
+
+error:
+        spider_net_free_rx_chain_contents(card);
+        return result;
+}
+
+/**
+ * spider_net_release_tx_descr - processes a used tx descriptor
+ * @card: card structure
+ * @descr: descriptor to release
+ *
+ * releases a used tx descriptor (unmapping, freeing of skb)
+ */
+static void
+spider_net_release_tx_descr(struct spider_net_card *card,
+                            struct spider_net_descr *descr)
+{
+        struct sk_buff *skb;
+
+        /* unmap the skb */
+        skb = descr->skb;
+        pci_unmap_single(card->pdev, descr->buf_addr, skb->len,
+                         PCI_DMA_BIDIRECTIONAL);
+
+        dev_kfree_skb_any(skb);
+
+        /* set status to not used */
+        spider_net_set_descr_status(descr, SPIDER_NET_DESCR_NOT_IN_USE);
+}
+
+/**
+ * spider_net_release_tx_chain - processes sent tx descriptors
+ * @card: adapter structure
+ * @brutal: if set, don't care about whether descriptor seems to be in use
+ *
+ * releases the tx descriptors that spider has finished with (if non-brutal)
+ * or simply release tx descriptors (if brutal)
+ */
+static void
+spider_net_release_tx_chain(struct spider_net_card *card, int brutal)
+{
+        struct spider_net_descr_chain *tx_chain = &card->tx_chain;
+        enum spider_net_descr_status status;
+
+        spider_net_tx_irq_off(card);
+
+        /* no lock for chain needed, if this is only executed once at a time */
+again:
+        for (;;) {
+                status = spider_net_get_descr_status(tx_chain->tail);
+                switch (status) {
+                case SPIDER_NET_DESCR_CARDOWNED:
+                        if (!brutal) goto out;
+                        /* fallthrough, if we release the descriptors
+                         * brutally (then we don't care about
+                         * SPIDER_NET_DESCR_CARDOWNED) */
+                case SPIDER_NET_DESCR_RESPONSE_ERROR:
+                case SPIDER_NET_DESCR_PROTECTION_ERROR:
+                case SPIDER_NET_DESCR_FORCE_END:
+                        if (netif_msg_tx_err(card))
+                                pr_err("%s: forcing end of tx descriptor "
+                                       "with status x%02x\n",
+                                       card->netdev->name, status);
+                        card->netdev_stats.tx_dropped++;
+                        break;
+
+                case SPIDER_NET_DESCR_COMPLETE:
+                        card->netdev_stats.tx_packets++;
+                        card->netdev_stats.tx_bytes +=
+                                tx_chain->tail->skb->len;
+                        break;
+
+                default: /* any other value (== SPIDER_NET_DESCR_NOT_IN_USE) */
+                        goto out;
+                }
+                spider_net_release_tx_descr(card, tx_chain->tail);
+                tx_chain->tail = tx_chain->tail->next;
+        }
+out:
+        netif_wake_queue(card->netdev);
+
+        if (!brutal) {
+                /* switch on tx irqs (while we are still in the interrupt
+                 * handler, so we don't get an interrupt), check again
+                 * for done descriptors. This results in fewer interrupts */
+                spider_net_tx_irq_on(card);
+                status = spider_net_get_descr_status(tx_chain->tail);
+                switch (status) {
+                        case SPIDER_NET_DESCR_RESPONSE_ERROR:
+                        case SPIDER_NET_DESCR_PROTECTION_ERROR:
+                        case SPIDER_NET_DESCR_FORCE_END:
+                        case SPIDER_NET_DESCR_COMPLETE:
+                                goto again;
+                        default:
+                                break;
+                }
+        }
+
+}
+
+/**
+ * spider_net_get_multicast_hash - generates hash for multicast filter table
+ * @addr: multicast address
+ *
+ * returns the hash value.
+ *
+ * spider_net_get_multicast_hash calculates a hash value for a given multicast
+ * address, that is used to set the multicast filter tables
+ */
+static u8
+spider_net_get_multicast_hash(struct net_device *netdev, __u8 *addr)
+{
+        /* FIXME: an addr of 01:00:5e:00:00:01 must result in 0xa9,
+         * ff:ff:ff:ff:ff:ff must result in 0xfd */
+        u32 crc;
+        u8 hash;
+
+        crc = crc32_be(~0, addr, netdev->addr_len);
+
+        hash = (crc >> 27);
+        hash <<= 3;
+        hash |= crc & 7;
+
+        return hash;
+}
+
+/**
+ * spider_net_set_multi - sets multicast addresses and promisc flags
+ * @netdev: interface device structure
+ *
+ * spider_net_set_multi configures multicast addresses as needed for the
+ * netdev interface. It also sets up multicast, allmulti and promisc
+ * flags appropriately
+ */
+static void
+spider_net_set_multi(struct net_device *netdev)
+{
+        struct dev_mc_list *mc;
+        u8 hash;
+        int i;
+        u32 reg;
+        struct spider_net_card *card = netdev_priv(netdev);
+        unsigned long bitmask[SPIDER_NET_MULTICAST_HASHES / BITS_PER_LONG] =
+                {0, };
+
+        spider_net_set_promisc(card);
+
+        if (netdev->flags & IFF_ALLMULTI) {
+                for (i = 0; i < SPIDER_NET_MULTICAST_HASHES; i++) {
+                        set_bit(i, bitmask);
+                }
+                goto write_hash;
+        }
+
+        /* well, we know, what the broadcast hash value is: it's xfd
+        hash = spider_net_get_multicast_hash(netdev, netdev->broadcast); */
+        set_bit(0xfd, bitmask);
+
+        for (mc = netdev->mc_list; mc; mc = mc->next) {
+                hash = spider_net_get_multicast_hash(netdev, mc->dmi_addr);
+                set_bit(hash, bitmask);
+        }
+
+write_hash:
+        for (i = 0; i < SPIDER_NET_MULTICAST_HASHES / 4; i++) {
+                reg = 0;
+                if (test_bit(i * 4, bitmask))
+                        reg += 0x08;
+                reg <<= 8;
+                if (test_bit(i * 4 + 1, bitmask))
+                        reg += 0x08;
+                reg <<= 8;
+                if (test_bit(i * 4 + 2, bitmask))
+                        reg += 0x08;
+                reg <<= 8;
+                if (test_bit(i * 4 + 3, bitmask))
+                        reg += 0x08;
+
+                spider_net_write_reg(card, SPIDER_NET_GMRMHFILnR + i * 4, reg);
+        }
+}
+
+/**
+ * spider_net_disable_rxdmac - disables the receive DMA controller
+ * @card: card structure
+ *
+ * spider_net_disable_rxdmac terminates processing on the DMA controller by
+ * turing off DMA and issueing a force end
+ */
+static void
+spider_net_disable_rxdmac(struct spider_net_card *card)
+{
+        spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR,
+                             SPIDER_NET_DMA_RX_FEND_VALUE);
+}
+
+/**
+ * spider_net_stop - called upon ifconfig down
+ * @netdev: interface device structure
+ *
+ * always returns 0
+ */
+int
+spider_net_stop(struct net_device *netdev)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+
+        netif_poll_disable(netdev);
+        netif_carrier_off(netdev);
+        netif_stop_queue(netdev);
+
+        /* disable/mask all interrupts */
+        spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, 0);
+        spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK, 0);
+        spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK, 0);
+
+        /* free_irq(netdev->irq, netdev);*/
+        free_irq(to_pci_dev(netdev->class_dev.dev)->irq, netdev);
+
+        spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR,
+                             SPIDER_NET_DMA_TX_FEND_VALUE);
+
+        /* turn off DMA, force end */
+        spider_net_disable_rxdmac(card);
+
+        /* release chains */
+        spider_net_release_tx_chain(card, 1);
+
+        spider_net_free_chain(card, &card->tx_chain);
+        spider_net_free_chain(card, &card->rx_chain);
+
+        return 0;
+}
+
+/**
+ * spider_net_get_next_tx_descr - returns the next available tx descriptor
+ * @card: device structure to get descriptor from
+ *
+ * returns the address of the next descriptor, or NULL if not available.
+ */
+static struct spider_net_descr *
+spider_net_get_next_tx_descr(struct spider_net_card *card)
+{
+        /* check, if head points to not-in-use descr */
+        if ( spider_net_get_descr_status(card->tx_chain.head) ==
+             SPIDER_NET_DESCR_NOT_IN_USE ) {
+                return card->tx_chain.head;
+        } else {
+                return NULL;
+        }
+}
+
+/**
+ * spider_net_set_txdescr_cmdstat - sets the tx descriptor command field
+ * @descr: descriptor structure to fill out
+ * @skb: packet to consider
+ *
+ * fills out the command and status field of the descriptor structure,
+ * depending on hardware checksum settings. This function assumes a wmb()
+ * has executed before.
+ */
+static void
+spider_net_set_txdescr_cmdstat(struct spider_net_descr *descr,
+                               struct sk_buff *skb)
+{
+        if (skb->ip_summed != CHECKSUM_HW) {
+                descr->dmac_cmd_status = SPIDER_NET_DMAC_CMDSTAT_NOCS;
+                return;
+        }
+
+        /* is packet ip?
+         * if yes: tcp? udp? */
+        if (skb->protocol == htons(ETH_P_IP)) {
+                if (skb->nh.iph->protocol == IPPROTO_TCP) {
+                        descr->dmac_cmd_status = SPIDER_NET_DMAC_CMDSTAT_TCPCS;
+                } else if (skb->nh.iph->protocol == IPPROTO_UDP) {
+                        descr->dmac_cmd_status = SPIDER_NET_DMAC_CMDSTAT_UDPCS;
+                } else { /* the stack should checksum non-tcp and non-udp
+                            packets on his own: NETIF_F_IP_CSUM */
+                        descr->dmac_cmd_status = SPIDER_NET_DMAC_CMDSTAT_NOCS;
+                }
+        }
+}
+
+/**
+ * spider_net_prepare_tx_descr - fill tx descriptor with skb data
+ * @card: card structure
+ * @descr: descriptor structure to fill out
+ * @skb: packet to use
+ *
+ * returns 0 on success, <0 on failure.
+ *
+ * fills out the descriptor structure with skb data and len. Copies data,
+ * if needed (32bit DMA!)
+ */
+static int
+spider_net_prepare_tx_descr(struct spider_net_card *card,
+                            struct spider_net_descr *descr,
+                            struct sk_buff *skb)
+{
+        descr->buf_addr = pci_map_single(card->pdev, skb->data,
+                                         skb->len, PCI_DMA_BIDIRECTIONAL);
+        if (descr->buf_addr == DMA_ERROR_CODE) {
+                if (netif_msg_tx_err(card))
+                        pr_err("could not iommu-map packet (%p, %i). "
+                                  "Dropping packet\n", skb->data, skb->len);
+                return -ENOMEM;
+        }
+
+        descr->buf_size = skb->len;
+        descr->skb = skb;
+        descr->data_status = 0;
+
+        /* make sure the above values are in memory before we change the
+         * status */
+        wmb();
+
+        spider_net_set_txdescr_cmdstat(descr,skb);
+
+        return 0;
+}
+
+/**
+ * spider_net_kick_tx_dma - enables TX DMA processing
+ * @card: card structure
+ * @descr: descriptor address to enable TX processing at
+ *
+ * spider_net_kick_tx_dma writes the current tx chain head as start address
+ * of the tx descriptor chain and enables the transmission DMA engine
+ */
+static void
+spider_net_kick_tx_dma(struct spider_net_card *card,
+                       struct spider_net_descr *descr)
+{
+        /* this is the only descriptor in the output chain.
+         * Enable TX DMA */
+
+        spider_net_write_reg(card, SPIDER_NET_GDTDCHA,
+                             descr->bus_addr);
+
+        spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR,
+                             SPIDER_NET_DMA_TX_VALUE);
+}
+
+/**
+ * spider_net_xmit - transmits a frame over the device
+ * @skb: packet to send out
+ * @netdev: interface device structure
+ *
+ * returns 0 on success, <0 on failure
+ */
+static int
+spider_net_xmit(struct sk_buff *skb, struct net_device *netdev)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        struct spider_net_descr *descr;
+        int result;
+
+        descr = spider_net_get_next_tx_descr(card);
+
+        if (!descr) {
+                netif_stop_queue(netdev);
+
+                descr = spider_net_get_next_tx_descr(card);
+                if (!descr)
+                        goto error;
+                else
+                        netif_start_queue(netdev);
+        }
+
+        result = spider_net_prepare_tx_descr(card, descr, skb);
+        if (result)
+                goto error;
+
+        card->tx_chain.head = card->tx_chain.head->next;
+
+        /* make sure the status from spider_net_prepare_tx_descr is in
+         * memory before we check out the previous descriptor */
+        wmb();
+
+        if (spider_net_get_descr_status(descr->prev) !=
+            SPIDER_NET_DESCR_CARDOWNED)
+                spider_net_kick_tx_dma(card, descr);
+
+        return NETDEV_TX_OK;
+
+error:
+        card->netdev_stats.tx_dropped++;
+        return NETDEV_TX_LOCKED;
+}
+
+/**
+ * spider_net_do_ioctl - called for device ioctls
+ * @netdev: interface device structure
+ * @ifr: request parameter structure for ioctl
+ * @cmd: command code for ioctl
+ *
+ * returns 0 on success, <0 on failure. Currently, we have no special ioctls.
+ * -EOPNOTSUPP is returned, if an unknown ioctl was requested
+ */
+static int
+spider_net_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
+{
+        switch (cmd) {
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
+/**
+ * spider_net_pass_skb_up - takes an skb from a descriptor and passes it on
+ * @descr: descriptor to process
+ * @card: card structure
+ *
+ * returns 1 on success, 0 if no packet was passed to the stack
+ *
+ * iommu-unmaps the skb, fills out skb structure and passes the data to the
+ * stack. The descriptor state is not changed.
+ */
+static int
+spider_net_pass_skb_up(struct spider_net_descr *descr,
+                       struct spider_net_card *card)
+{
+        struct sk_buff *skb;
+        struct net_device *netdev;
+        u32 data_status, data_error;
+
+        data_status = descr->data_status;
+        data_error = descr->data_error;
+
+        netdev = card->netdev;
+
+        /* check for errors in the data_error flag */
+        if ((data_error & SPIDER_NET_DATA_ERROR_MASK) &&
+            netif_msg_rx_err(card))
+                pr_err("error in received descriptor found, "
+                       "data_status=x%08x, data_error=x%08x\n",
+                       data_status, data_error);
+
+        /* prepare skb, unmap descriptor */
+        skb = descr->skb;
+        pci_unmap_single(card->pdev, descr->buf_addr, SPIDER_NET_MAX_MTU,
+                         PCI_DMA_BIDIRECTIONAL);
+
+        /* the cases we'll throw away the packet immediately */
+        if (data_error & SPIDER_NET_DESTROY_RX_FLAGS)
+                return 0;
+
+        skb->dev = netdev;
+        skb_put(skb, descr->valid_size);
+
+        /* the card seems to add 2 bytes of junk in front
+         * of the ethernet frame */
+#define SPIDER_MISALIGN         2
+        skb_pull(skb, SPIDER_MISALIGN);
+        skb->protocol = eth_type_trans(skb, netdev);
+
+        /* checksum offload */
+        if (card->options.rx_csum) {
+                if ( (data_status & SPIDER_NET_DATA_STATUS_CHK_MASK) &&
+                     (!(data_error & SPIDER_NET_DATA_ERROR_CHK_MASK)) )
+                        skb->ip_summed = CHECKSUM_UNNECESSARY;
+                else
+                        skb->ip_summed = CHECKSUM_NONE;
+        } else {
+                skb->ip_summed = CHECKSUM_NONE;
+        }
+
+        if (data_status & SPIDER_NET_VLAN_PACKET) {
+                /* further enhancements: HW-accel VLAN
+                 * vlan_hwaccel_receive_skb
+                 */
+        }
+
+        /* pass skb up to stack */
+        netif_receive_skb(skb);
+
+        /* update netdevice statistics */
+        card->netdev_stats.rx_packets++;
+        card->netdev_stats.rx_bytes += skb->len;
+
+        return 1;
+}
+
+/**
+ * spider_net_decode_descr - processes an rx descriptor
+ * @card: card structure
+ *
+ * returns 1 if a packet has been sent to the stack, otherwise 0
+ *
+ * processes an rx descriptor by iommu-unmapping the data buffer and passing
+ * the packet up to the stack
+ */
+static int
+spider_net_decode_one_descr(struct spider_net_card *card)
+{
+        enum spider_net_descr_status status;
+        struct spider_net_descr *descr;
+        struct spider_net_descr_chain *chain;
+        int result;
+
+        chain = &card->rx_chain;
+        descr = chain->tail;
+
+        status = spider_net_get_descr_status(descr);
+
+        if (status == SPIDER_NET_DESCR_CARDOWNED) {
+                /* nothing in the descriptor yet */
+                return 0;
+        }
+
+        if (status == SPIDER_NET_DESCR_NOT_IN_USE) {
+                /* not initialized yet, I bet chain->tail == chain->head
+                 * and the ring is empty */
+                spider_net_refill_rx_chain(card);
+                return 0;
+        }
+
+        /* descriptor definitively used -- move on head */
+        chain->tail = descr->next;
+
+        result = 0;
+        if ( (status == SPIDER_NET_DESCR_RESPONSE_ERROR) ||
+             (status == SPIDER_NET_DESCR_PROTECTION_ERROR) ||
+             (status == SPIDER_NET_DESCR_FORCE_END) ) {
+                if (netif_msg_rx_err(card))
+                        pr_err("%s: dropping RX descriptor with state %d\n",
+                               card->netdev->name, status);
+                card->netdev_stats.rx_dropped++;
+                goto refill;
+        }
+
+        if ( (status != SPIDER_NET_DESCR_COMPLETE) &&
+             (status != SPIDER_NET_DESCR_FRAME_END) ) {
+                if (netif_msg_rx_err(card))
+                        pr_err("%s: RX descriptor with state %d\n",
+                               card->netdev->name, status);
+                goto refill;
+        }
+
+        /* ok, we've got a packet in descr */
+        result = spider_net_pass_skb_up(descr, card);
+refill:
+        spider_net_set_descr_status(descr, SPIDER_NET_DESCR_NOT_IN_USE);
+        /* change the descriptor state: */
+        spider_net_refill_rx_chain(card);
+
+        return result;
+}
+
+/**
+ * spider_net_poll - NAPI poll function called by the stack to return packets
+ * @netdev: interface device structure
+ * @budget: number of packets we can pass to the stack at most
+ *
+ * returns 0 if no more packets available to the driver/stack. Returns 1,
+ * if the quota is exceeded, but the driver has still packets.
+ *
+ * spider_net_poll returns all packets from the rx descriptors to the stack
+ * (using netif_receive_skb). If all/enough packets are up, the driver
+ * reenables interrupts and returns 0. If not, 1 is returned.
+ */
+static int
+spider_net_poll(struct net_device *netdev, int *budget)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        int packets_to_do, packets_done = 0;
+        int no_more_packets = 0;
+
+        packets_to_do = min(*budget, netdev->quota);
+
+        while (packets_to_do) {
+                if (spider_net_decode_one_descr(card)) {
+                        packets_done++;
+                        packets_to_do--;
+                } else {
+                        /* no more packets for the stack */
+                        no_more_packets = 1;
+                        break;
+                }
+        }
+
+        netdev->quota -= packets_done;
+        *budget -= packets_done;
+
+        /* if all packets are in the stack, enable interrupts and return 0 */
+        /* if not, return 1 */
+        if (no_more_packets) {
+                netif_rx_complete(netdev);
+                spider_net_rx_irq_on(card);
+                return 0;
+        }
+
+        return 1;
+}
+
+/**
+ * spider_net_vlan_rx_reg - initializes VLAN structures in the driver and card
+ * @netdev: interface device structure
+ * @grp: vlan_group structure that is registered (NULL on destroying interface)
+ */
+static void
+spider_net_vlan_rx_reg(struct net_device *netdev, struct vlan_group *grp)
+{
+        /* further enhancement... yet to do */
+        return;
+}
+
+/**
+ * spider_net_vlan_rx_add - adds VLAN id to the card filter
+ * @netdev: interface device structure
+ * @vid: VLAN id to add
+ */
+static void
+spider_net_vlan_rx_add(struct net_device *netdev, uint16_t vid)
+{
+        /* further enhancement... yet to do */
+        /* add vid to card's VLAN filter table */
+        return;
+}
+
+/**
+ * spider_net_vlan_rx_kill - removes VLAN id to the card filter
+ * @netdev: interface device structure
+ * @vid: VLAN id to remove
+ */
+static void
+spider_net_vlan_rx_kill(struct net_device *netdev, uint16_t vid)
+{
+        /* further enhancement... yet to do */
+        /* remove vid from card's VLAN filter table */
+}
+
+/**
+ * spider_net_get_stats - get interface statistics
+ * @netdev: interface device structure
+ *
+ * returns the interface statistics residing in the spider_net_card struct
+ */
+static struct net_device_stats *
+spider_net_get_stats(struct net_device *netdev)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        struct net_device_stats *stats = &card->netdev_stats;
+        return stats;
+}
+
+/**
+ * spider_net_change_mtu - changes the MTU of an interface
+ * @netdev: interface device structure
+ * @new_mtu: new MTU value
+ *
+ * returns 0 on success, <0 on failure
+ */
+static int
+spider_net_change_mtu(struct net_device *netdev, int new_mtu)
+{
+        /* no need to re-alloc skbs or so -- the max mtu is about 2.3k
+         * and mtu is outbound only anyway */
+        if ( (new_mtu < SPIDER_NET_MIN_MTU ) ||
+                (new_mtu > SPIDER_NET_MAX_MTU) )
+                return -EINVAL;
+        netdev->mtu = new_mtu;
+        return 0;
+}
+
+/**
+ * spider_net_set_mac - sets the MAC of an interface
+ * @netdev: interface device structure
+ * @ptr: pointer to new MAC address
+ *
+ * Returns 0 on success, <0 on failure. Currently, we don't support this
+ * and will always return EOPNOTSUPP.
+ */
+static int
+spider_net_set_mac(struct net_device *netdev, void *p)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        u32 macl, macu, regvalue;
+        struct sockaddr *addr = p;
+
+        if (!is_valid_ether_addr(addr->sa_data))
+                return -EADDRNOTAVAIL;
+
+        /* switch off GMACTPE and GMACRPE */
+        regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD);
+        regvalue &= ~((1 << 5) | (1 << 6));
+        spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue);
+
+        /* write mac */
+        macu = (addr->sa_data[0]<<24) + (addr->sa_data[1]<<16) +
+                (addr->sa_data[2]<<8) + (addr->sa_data[3]);
+        macl = (addr->sa_data[4]<<8) + (addr->sa_data[5]);
+        spider_net_write_reg(card, SPIDER_NET_GMACUNIMACU, macu);
+        spider_net_write_reg(card, SPIDER_NET_GMACUNIMACL, macl);
+
+        /* switch GMACTPE and GMACRPE back on */
+        regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD);
+        regvalue |= ((1 << 5) | (1 << 6));
+        spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue);
+
+        spider_net_set_promisc(card);
+
+        /* look up, whether we have been successful */
+        if (spider_net_get_mac_address(netdev))
+                return -EADDRNOTAVAIL;
+        if (memcmp(netdev->dev_addr,addr->sa_data,netdev->addr_len))
+                return -EADDRNOTAVAIL;
+
+        return 0;
+}
+
+/**
+ * spider_net_enable_txdmac - enables a TX DMA controller
+ * @card: card structure
+ *
+ * spider_net_enable_txdmac enables the TX DMA controller by setting the
+ * descriptor chain tail address
+ */
+static void
+spider_net_enable_txdmac(struct spider_net_card *card)
+{
+        /* assume chain is aligned correctly */
+        spider_net_write_reg(card, SPIDER_NET_GDTDCHA,
+                             card->tx_chain.tail->bus_addr);
+}
+
+/**
+ * spider_net_handle_error_irq - handles errors raised by an interrupt
+ * @card: card structure
+ * @status_reg: interrupt status register 0 (GHIINT0STS)
+ *
+ * spider_net_handle_error_irq treats or ignores all error conditions
+ * found when an interrupt is presented
+ */
+static void
+spider_net_handle_error_irq(struct spider_net_card *card, u32 status_reg)
+{
+        u32 error_reg1, error_reg2;
+        u32 i;
+        int show_error = 1;
+
+        error_reg1 = spider_net_read_reg(card, SPIDER_NET_GHIINT1STS);
+        error_reg2 = spider_net_read_reg(card, SPIDER_NET_GHIINT2STS);
+
+        /* check GHIINT0STS ************************************/
+        if (status_reg)
+                for (i = 0; i < 32; i++)
+                        if (status_reg & (1<<i))
+                                switch (i)
+        {
+        /* let error_reg1 and error_reg2 evaluation decide, what to do
+        case SPIDER_NET_PHYINT:
+        case SPIDER_NET_GMAC2INT:
+        case SPIDER_NET_GMAC1INT:
+        case SPIDER_NET_GIPSINT:
+        case SPIDER_NET_GFIFOINT:
+        case SPIDER_NET_DMACINT:
+        case SPIDER_NET_GSYSINT:
+                break; */
+
+        case SPIDER_NET_GPWOPCMPINT:
+                /* PHY write operation completed */
+                show_error = 0;
+                break;
+        case SPIDER_NET_GPROPCMPINT:
+                /* PHY read operation completed */
+                /* we don't use semaphores, as we poll for the completion
+                 * of the read operation in spider_net_read_phy. Should take
+                 * about 50 us */
+                show_error = 0;
+                break;
+        case SPIDER_NET_GPWFFINT:
+                /* PHY command queue full */
+                if (netif_msg_intr(card))
+                        pr_err("PHY write queue full\n");
+                show_error = 0;
+                break;
+
+        /* case SPIDER_NET_GRMDADRINT: not used. print a message */
+        /* case SPIDER_NET_GRMARPINT: not used. print a message */
+        /* case SPIDER_NET_GRMMPINT: not used. print a message */
+
+        case SPIDER_NET_GDTDEN0INT:
+                /* someone has set TX_DMA_EN to 0 */
+                show_error = 0;
+                break;
+
+        case SPIDER_NET_GDDDEN0INT: /* fallthrough */
+        case SPIDER_NET_GDCDEN0INT: /* fallthrough */
+        case SPIDER_NET_GDBDEN0INT: /* fallthrough */
+        case SPIDER_NET_GDADEN0INT:
+                /* someone has set RX_DMA_EN to 0 */
+                show_error = 0;
+                break;
+
+        /* RX interrupts */
+        case SPIDER_NET_GDDFDCINT:
+        case SPIDER_NET_GDCFDCINT:
+        case SPIDER_NET_GDBFDCINT:
+        case SPIDER_NET_GDAFDCINT:
+        /* case SPIDER_NET_GDNMINT: not used. print a message */
+        /* case SPIDER_NET_GCNMINT: not used. print a message */
+        /* case SPIDER_NET_GBNMINT: not used. print a message */
+        /* case SPIDER_NET_GANMINT: not used. print a message */
+        /* case SPIDER_NET_GRFNMINT: not used. print a message */
+                show_error = 0;
+                break;
+
+        /* TX interrupts */
+        case SPIDER_NET_GDTFDCINT:
+                show_error = 0;
+                break;
+        case SPIDER_NET_GTTEDINT:
+                show_error = 0;
+                break;
+        case SPIDER_NET_GDTDCEINT:
+                /* chain end. If a descriptor should be sent, kick off
+                 * tx dma
+                if (card->tx_chain.tail == card->tx_chain.head)
+                        spider_net_kick_tx_dma(card);
+                show_error = 0; */
+                break;
+
+        /* case SPIDER_NET_G1TMCNTINT: not used. print a message */
+        /* case SPIDER_NET_GFREECNTINT: not used. print a message */
+        }
+
+        /* check GHIINT1STS ************************************/
+        if (error_reg1)
+                for (i = 0; i < 32; i++)
+                        if (error_reg1 & (1<<i))
+                                switch (i)
+        {
+        case SPIDER_NET_GTMFLLINT:
+                if (netif_msg_intr(card))
+                        pr_err("Spider TX RAM full\n");
+                show_error = 0;
+                break;
+        case SPIDER_NET_GRMFLLINT:
+                if (netif_msg_intr(card))
+                        pr_err("Spider RX RAM full, incoming packets "
+                               "might be discarded !\n");
+                netif_rx_schedule(card->netdev);
+                spider_net_enable_rxchtails(card);
+                spider_net_enable_rxdmac(card);
+                break;
+
+        /* case SPIDER_NET_GTMSHTINT: problem, print a message */
+        case SPIDER_NET_GDTINVDINT:
+                /* allrighty. tx from previous descr ok */
+                show_error = 0;
+                break;
+        /* case SPIDER_NET_GRFDFLLINT: print a message down there */
+        /* case SPIDER_NET_GRFCFLLINT: print a message down there */
+        /* case SPIDER_NET_GRFBFLLINT: print a message down there */
+        /* case SPIDER_NET_GRFAFLLINT: print a message down there */
+
+        /* chain end */
+        case SPIDER_NET_GDDDCEINT: /* fallthrough */
+        case SPIDER_NET_GDCDCEINT: /* fallthrough */
+        case SPIDER_NET_GDBDCEINT: /* fallthrough */
+        case SPIDER_NET_GDADCEINT:
+                if (netif_msg_intr(card))
+                        pr_err("got descriptor chain end interrupt, "
+                               "restarting DMAC %c.\n",
+                               'D'+i-SPIDER_NET_GDDDCEINT);
+                spider_net_refill_rx_chain(card);
+                show_error = 0;
+                break;
+
+        /* invalid descriptor */
+        case SPIDER_NET_GDDINVDINT: /* fallthrough */
+        case SPIDER_NET_GDCINVDINT: /* fallthrough */
+        case SPIDER_NET_GDBINVDINT: /* fallthrough */
+        case SPIDER_NET_GDAINVDINT:
+                /* could happen when rx chain is full */
+                spider_net_refill_rx_chain(card);
+                show_error = 0;
+                break;
+
+        /* case SPIDER_NET_GDTRSERINT: problem, print a message */
+        /* case SPIDER_NET_GDDRSERINT: problem, print a message */
+        /* case SPIDER_NET_GDCRSERINT: problem, print a message */
+        /* case SPIDER_NET_GDBRSERINT: problem, print a message */
+        /* case SPIDER_NET_GDARSERINT: problem, print a message */
+        /* case SPIDER_NET_GDSERINT: problem, print a message */
+        /* case SPIDER_NET_GDTPTERINT: problem, print a message */
+        /* case SPIDER_NET_GDDPTERINT: problem, print a message */
+        /* case SPIDER_NET_GDCPTERINT: problem, print a message */
+        /* case SPIDER_NET_GDBPTERINT: problem, print a message */
+        /* case SPIDER_NET_GDAPTERINT: problem, print a message */
+        default:
+                show_error = 1;
+                break;
+        }
+
+        /* check GHIINT2STS ************************************/
+        if (error_reg2)
+                for (i = 0; i < 32; i++)
+                        if (error_reg2 & (1<<i))
+                                switch (i)
+        {
+        /* there is nothing we can (want  to) do at this time. Log a
+         * message, we can switch on and off the specific values later on
+        case SPIDER_NET_GPROPERINT:
+        case SPIDER_NET_GMCTCRSNGINT:
+        case SPIDER_NET_GMCTLCOLINT:
+        case SPIDER_NET_GMCTTMOTINT:
+        case SPIDER_NET_GMCRCAERINT:
+        case SPIDER_NET_GMCRCALERINT:
+        case SPIDER_NET_GMCRALNERINT:
+        case SPIDER_NET_GMCROVRINT:
+        case SPIDER_NET_GMCRRNTINT:
+        case SPIDER_NET_GMCRRXERINT:
+        case SPIDER_NET_GTITCSERINT:
+        case SPIDER_NET_GTIFMTERINT:
+        case SPIDER_NET_GTIPKTRVKINT:
+        case SPIDER_NET_GTISPINGINT:
+        case SPIDER_NET_GTISADNGINT:
+        case SPIDER_NET_GTISPDNGINT:
+        case SPIDER_NET_GRIFMTERINT:
+        case SPIDER_NET_GRIPKTRVKINT:
+        case SPIDER_NET_GRISPINGINT:
+        case SPIDER_NET_GRISADNGINT:
+        case SPIDER_NET_GRISPDNGINT:
+                break;
+        */
+                default:
+                        break;
+        }
+
+        if ((show_error) && (netif_msg_intr(card)))
+                pr_err("Got error interrupt, GHIINT0STS = 0x%08x, "
+                       "GHIINT1STS = 0x%08x, GHIINT2STS = 0x%08x\n",
+                       status_reg, error_reg1, error_reg2);
+
+        /* clear interrupt sources */
+        spider_net_write_reg(card, SPIDER_NET_GHIINT1STS, error_reg1);
+        spider_net_write_reg(card, SPIDER_NET_GHIINT2STS, error_reg2);
+}
+
+/**
+ * spider_net_interrupt - interrupt handler for spider_net
+ * @irq: interupt number
+ * @ptr: pointer to net_device
+ * @regs: PU registers
+ *
+ * returns IRQ_HANDLED, if interrupt was for driver, or IRQ_NONE, if no
+ * interrupt found raised by card.
+ *
+ * This is the interrupt handler, that turns off
+ * interrupts for this device and makes the stack poll the driver
+ */
+static irqreturn_t
+spider_net_interrupt(int irq, void *ptr, struct pt_regs *regs)
+{
+        struct net_device *netdev = ptr;
+        struct spider_net_card *card = netdev_priv(netdev);
+        u32 status_reg;
+
+        status_reg = spider_net_read_reg(card, SPIDER_NET_GHIINT0STS);
+
+        if (!status_reg)
+                return IRQ_NONE;
+
+        if (status_reg & SPIDER_NET_TXINT)
+                spider_net_release_tx_chain(card, 0);
+
+        if (status_reg & SPIDER_NET_RXINT ) {
+                spider_net_rx_irq_off(card);
+                netif_rx_schedule(netdev);
+        }
+
+        /* we do this after rx and tx processing, as we want the tx chain
+         * processed to see, whether we should restart tx dma processing */
+        spider_net_handle_error_irq(card, status_reg);
+
+        /* clear interrupt sources */
+        spider_net_write_reg(card, SPIDER_NET_GHIINT0STS, status_reg);
+
+        return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_NET_POLL_CONTROLLER
+/**
+ * spider_net_poll_controller - artificial interrupt for netconsole etc.
+ * @netdev: interface device structure
+ *
+ * see Documentation/networking/netconsole.txt
+ */
+static void
+spider_net_poll_controller(struct net_device *netdev)
+{
+        disable_irq(netdev->irq);
+        spider_net_interrupt(netdev->irq, netdev, NULL);
+        enable_irq(netdev->irq);
+}
+#endif /* CONFIG_NET_POLL_CONTROLLER */
+
+/**
+ * spider_net_init_card - initializes the card
+ * @card: card structure
+ *
+ * spider_net_init_card initializes the card so that other registers can
+ * be used
+ */
+static void
+spider_net_init_card(struct spider_net_card *card)
+{
+        spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
+                             SPIDER_NET_CKRCTRL_STOP_VALUE);
+
+        spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
+                             SPIDER_NET_CKRCTRL_RUN_VALUE);
+}
+
+/**
+ * spider_net_enable_card - enables the card by setting all kinds of regs
+ * @card: card structure
+ *
+ * spider_net_enable_card sets a lot of SMMIO registers to enable the device
+ */
+static void
+spider_net_enable_card(struct spider_net_card *card)
+{
+        int i;
+        /* the following array consists of (register),(value) pairs
+         * that are set in this function. A register of 0 ends the list */
+        u32 regs[][2] = {
+                { SPIDER_NET_GRESUMINTNUM, 0 },
+                { SPIDER_NET_GREINTNUM, 0 },
+
+                /* set interrupt frame number registers */
+                /* clear the single DMA engine registers first */
+                { SPIDER_NET_GFAFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
+                { SPIDER_NET_GFBFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
+                { SPIDER_NET_GFCFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
+                { SPIDER_NET_GFDFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
+                /* then set, what we really need */
+                { SPIDER_NET_GFFRMNUM, SPIDER_NET_FRAMENUM_VALUE },
+
+                /* timer counter registers and stuff */
+                { SPIDER_NET_GFREECNNUM, 0 },
+                { SPIDER_NET_GONETIMENUM, 0 },
+                { SPIDER_NET_GTOUTFRMNUM, 0 },
+
+                /* RX mode setting */
+                { SPIDER_NET_GRXMDSET, SPIDER_NET_RXMODE_VALUE },
+                /* TX mode setting */
+                { SPIDER_NET_GTXMDSET, SPIDER_NET_TXMODE_VALUE },
+                /* IPSEC mode setting */
+                { SPIDER_NET_GIPSECINIT, SPIDER_NET_IPSECINIT_VALUE },
+
+                { SPIDER_NET_GFTRESTRT, SPIDER_NET_RESTART_VALUE },
+
+                { SPIDER_NET_GMRWOLCTRL, 0 },
+                { SPIDER_NET_GTESTMD, 0 },
+
+                { SPIDER_NET_GMACINTEN, 0 },
+
+                /* flow control stuff */
+                { SPIDER_NET_GMACAPAUSE, SPIDER_NET_MACAPAUSE_VALUE },
+                { SPIDER_NET_GMACTXPAUSE, SPIDER_NET_TXPAUSE_VALUE },
+
+                { SPIDER_NET_GMACBSTLMT, SPIDER_NET_BURSTLMT_VALUE },
+                { 0, 0}
+        };
+
+        i = 0;
+        while (regs[i][0]) {
+                spider_net_write_reg(card, regs[i][0], regs[i][1]);
+                i++;
+        }
+
+        /* clear unicast filter table entries 1 to 14 */
+        for (i = 1; i <= 14; i++) {
+                spider_net_write_reg(card,
+                                     SPIDER_NET_GMRUAFILnR + i * 8,
+                                     0x00080000);
+                spider_net_write_reg(card,
+                                     SPIDER_NET_GMRUAFILnR + i * 8 + 4,
+                                     0x00000000);
+        }
+
+        spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R, 0x08080000);
+
+        spider_net_write_reg(card, SPIDER_NET_ECMODE, SPIDER_NET_ECMODE_VALUE);
+
+        /* set chain tail adress for RX chains and
+         * enable DMA */
+        spider_net_enable_rxchtails(card);
+        spider_net_enable_rxdmac(card);
+
+        spider_net_write_reg(card, SPIDER_NET_GRXDMAEN, SPIDER_NET_WOL_VALUE);
+
+        /* set chain tail adress for TX chain */
+        spider_net_enable_txdmac(card);
+
+        spider_net_write_reg(card, SPIDER_NET_GMACLENLMT,
+                             SPIDER_NET_LENLMT_VALUE);
+        spider_net_write_reg(card, SPIDER_NET_GMACMODE,
+                             SPIDER_NET_MACMODE_VALUE);
+        spider_net_write_reg(card, SPIDER_NET_GMACOPEMD,
+                             SPIDER_NET_OPMODE_VALUE);
+
+        /* set interrupt mask registers */
+        spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK,
+                             SPIDER_NET_INT0_MASK_VALUE);
+        spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK,
+                             SPIDER_NET_INT1_MASK_VALUE);
+        spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK,
+                             SPIDER_NET_INT2_MASK_VALUE);
+}
+
+/**
+ * spider_net_open - called upon ifonfig up
+ * @netdev: interface device structure
+ *
+ * returns 0 on success, <0 on failure
+ *
+ * spider_net_open allocates all the descriptors and memory needed for
+ * operation, sets up multicast list and enables interrupts
+ */
+int
+spider_net_open(struct net_device *netdev)
+{
+        struct spider_net_card *card = netdev_priv(netdev);
+        int result;
+
+        result = -ENOMEM;
+        if (spider_net_init_chain(card, &card->tx_chain,
+                          card->descr, tx_descriptors))
+                goto alloc_tx_failed;
+        if (spider_net_init_chain(card, &card->rx_chain,
+                          card->descr + tx_descriptors, rx_descriptors))
+                goto alloc_rx_failed;
+
+        /* allocate rx skbs */
+        if (spider_net_alloc_rx_skbs(card))
+                goto alloc_skbs_failed;
+
+        spider_net_set_multi(netdev);
+
+        /* further enhancement: setup hw vlan, if needed */
+
+        result = -EBUSY;
+        if (request_irq(netdev->irq, spider_net_interrupt,
+                             SA_SHIRQ, netdev->name, netdev))
+                goto register_int_failed;
+
+        spider_net_enable_card(card);
+
+        netif_start_queue(netdev);
+        netif_carrier_on(netdev);
+        netif_poll_enable(netdev);
+
+        return 0;
+
+register_int_failed:
+        spider_net_free_rx_chain_contents(card);
+alloc_skbs_failed:
+        spider_net_free_chain(card, &card->rx_chain);
+alloc_rx_failed:
+        spider_net_free_chain(card, &card->tx_chain);
+alloc_tx_failed:
+        return result;
+}
+
+/**
+ * spider_net_setup_phy - setup PHY
+ * @card: card structure
+ *
+ * returns 0 on success, <0 on failure
+ *
+ * spider_net_setup_phy is used as part of spider_net_probe. Sets
+ * the PHY to 1000 Mbps
+ **/
+static int
+spider_net_setup_phy(struct spider_net_card *card)
+{
+        struct mii_phy *phy = &card->phy;
+
+        spider_net_write_reg(card, SPIDER_NET_GDTDMASEL,
+                             SPIDER_NET_DMASEL_VALUE);
+        spider_net_write_reg(card, SPIDER_NET_GPCCTRL,
+                             SPIDER_NET_PHY_CTRL_VALUE);
+        phy->mii_id = 1;
+        phy->dev = card->netdev;
+        phy->mdio_read = spider_net_read_phy;
+        phy->mdio_write = spider_net_write_phy;
+
+        mii_phy_probe(phy, phy->mii_id);
+
+        if (phy->def->ops->setup_forced)
+                phy->def->ops->setup_forced(phy, SPEED_1000, DUPLEX_FULL);
+
+        /* the following two writes could be moved to sungem_phy.c */
+        /* enable fiber mode */
+        spider_net_write_phy(card->netdev, 1, MII_NCONFIG, 0x9020);
+        /* LEDs active in both modes, autosense prio = fiber */
+        spider_net_write_phy(card->netdev, 1, MII_NCONFIG, 0x945f);
+
+        phy->def->ops->read_link(phy);
+        pr_info("Found %s with %i Mbps, %s-duplex.\n", phy->def->name,
+                phy->speed, phy->duplex==1 ? "Full" : "Half");
+
+        return 0;
+}
+
+/**
+ * spider_net_download_firmware - loads firmware into the adapter
+ * @card: card structure
+ * @firmware: firmware pointer
+ *
+ * spider_net_download_firmware loads the firmware opened by
+ * spider_net_init_firmware into the adapter.
+ */
+static void
+spider_net_download_firmware(struct spider_net_card *card,
+                             const struct firmware *firmware)
+{
+        int sequencer, i;
+        u32 *fw_ptr = (u32 *)firmware->data;
+
+        /* stop sequencers */
+        spider_net_write_reg(card, SPIDER_NET_GSINIT,
+                             SPIDER_NET_STOP_SEQ_VALUE);
+
+        for (sequencer = 0; sequencer < 6; sequencer++) {
+                spider_net_write_reg(card,
+                                     SPIDER_NET_GSnPRGADR + sequencer * 8, 0);
+                for (i = 0; i < SPIDER_NET_FIRMWARE_LEN; i++) {
+                        spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT +
+                                             sequencer * 8, *fw_ptr);
+                        fw_ptr++;
+                }
+        }
+
+        spider_net_write_reg(card, SPIDER_NET_GSINIT,
+                             SPIDER_NET_RUN_SEQ_VALUE);
+}
+
+/**
+ * spider_net_init_firmware - reads in firmware parts
+ * @card: card structure
+ *
+ * Returns 0 on success, <0 on failure
+ *
+ * spider_net_init_firmware opens the sequencer firmware and does some basic
+ * checks. This function opens and releases the firmware structure. A call
+ * to download the firmware is performed before the release.
+ *
+ * Firmware format
+ * ===============
+ * spider_fw.bin is expected to be a file containing 6*1024*4 bytes, 4k being
+ * the program for each sequencer. Use the command
+ *    tail -q -n +2 Seq_code1_0x088.txt Seq_code2_0x090.txt              \
+ *         Seq_code3_0x098.txt Seq_code4_0x0A0.txt Seq_code5_0x0A8.txt   \
+ *         Seq_code6_0x0B0.txt | xxd -r -p -c4 > spider_fw.bin
+ *
+ * to generate spider_fw.bin, if you have sequencer programs with something
+ * like the following contents for each sequencer:
+ *    <ONE LINE COMMENT>
+ *    <FIRST 4-BYTES-WORD FOR SEQUENCER>
+ *    <SECOND 4-BYTES-WORD FOR SEQUENCER>
+ *     ...
+ *    <1024th 4-BYTES-WORD FOR SEQUENCER>
+ */
+static int
+spider_net_init_firmware(struct spider_net_card *card)
+{
+        const struct firmware *firmware;
+        int err = -EIO;
+
+        if (request_firmware(&firmware,
+                             SPIDER_NET_FIRMWARE_NAME, &card->pdev->dev) < 0) {
+                if (netif_msg_probe(card))
+                        pr_err("Couldn't read in sequencer data file %s.\n",
+                               SPIDER_NET_FIRMWARE_NAME);
+                firmware = NULL;
+                goto out;
+        }
+
+        if (firmware->size != 6 * SPIDER_NET_FIRMWARE_LEN * sizeof(u32)) {
+                if (netif_msg_probe(card))
+                        pr_err("Invalid size of sequencer data file %s.\n",
+                               SPIDER_NET_FIRMWARE_NAME);
+                goto out;
+        }
+
+        spider_net_download_firmware(card, firmware);
+
+        err = 0;
+out:
+        release_firmware(firmware);
+
+        return err;
+}
+
+/**
+ * spider_net_workaround_rxramfull - work around firmware bug
+ * @card: card structure
+ *
+ * no return value
+ **/
+static void
+spider_net_workaround_rxramfull(struct spider_net_card *card)
+{
+        int i, sequencer = 0;
+
+        /* cancel reset */
+        spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
+                             SPIDER_NET_CKRCTRL_RUN_VALUE);
+
+        /* empty sequencer data */
+        for (sequencer = 0; sequencer < 6; sequencer++) {
+                spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT +
+                                     sequencer * 8, 0x0);
+                for (i = 0; i < SPIDER_NET_FIRMWARE_LEN; i++) {
+                        spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT +
+                                             sequencer * 8, 0x0);
+                }
+        }
+
+        /* set sequencer operation */
+        spider_net_write_reg(card, SPIDER_NET_GSINIT, 0x000000fe);
+
+        /* reset */
+        spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
+                             SPIDER_NET_CKRCTRL_STOP_VALUE);
+}
+
+/**
+ * spider_net_tx_timeout_task - task scheduled by the watchdog timeout
+ * function (to be called not under interrupt status)
+ * @data: data, is interface device structure
+ *
+ * called as task when tx hangs, resets interface (if interface is up)
+ */
+static void
+spider_net_tx_timeout_task(void *data)
+{
+        struct net_device *netdev = data;
+        struct spider_net_card *card = netdev_priv(netdev);
+
+        if (!(netdev->flags & IFF_UP))
+                goto out;
+
+        netif_device_detach(netdev);
+        spider_net_stop(netdev);
+
+        spider_net_workaround_rxramfull(card);
+        spider_net_init_card(card);
+
+        if (spider_net_setup_phy(card))
+                goto out;
+        if (spider_net_init_firmware(card))
+                goto out;
+
+        spider_net_open(netdev);
+        spider_net_kick_tx_dma(card, card->tx_chain.head);
+        netif_device_attach(netdev);
+
+out:
+        atomic_dec(&card->tx_timeout_task_counter);
+}
+
+/**
+ * spider_net_tx_timeout - called when the tx timeout watchdog kicks in.
+ * @netdev: interface device structure
+ *
+ * called, if tx hangs. Schedules a task that resets the interface
+ */
+static void
+spider_net_tx_timeout(struct net_device *netdev)
+{
+        struct spider_net_card *card;
+
+        card = netdev_priv(netdev);
+        atomic_inc(&card->tx_timeout_task_counter);
+        if (netdev->flags & IFF_UP)
+                schedule_work(&card->tx_timeout_task);
+        else
+                atomic_dec(&card->tx_timeout_task_counter);
+}
+
+/**
+ * spider_net_setup_netdev_ops - initialization of net_device operations
+ * @netdev: net_device structure
+ *
+ * fills out function pointers in the net_device structure
+ */
+static void
+spider_net_setup_netdev_ops(struct net_device *netdev)
+{
+        netdev->open = &spider_net_open;
+        netdev->stop = &spider_net_stop;
+        netdev->hard_start_xmit = &spider_net_xmit;
+        netdev->get_stats = &spider_net_get_stats;
+        netdev->set_multicast_list = &spider_net_set_multi;
+        netdev->set_mac_address = &spider_net_set_mac;
+        netdev->change_mtu = &spider_net_change_mtu;
+        netdev->do_ioctl = &spider_net_do_ioctl;
+        /* tx watchdog */
+        netdev->tx_timeout = &spider_net_tx_timeout;
+        netdev->watchdog_timeo = SPIDER_NET_WATCHDOG_TIMEOUT;
+        /* NAPI */
+        netdev->poll = &spider_net_poll;
+        netdev->weight = SPIDER_NET_NAPI_WEIGHT;
+        /* HW VLAN */
+        netdev->vlan_rx_register = &spider_net_vlan_rx_reg;
+        netdev->vlan_rx_add_vid = &spider_net_vlan_rx_add;
+        netdev->vlan_rx_kill_vid = &spider_net_vlan_rx_kill;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        /* poll controller */
+        netdev->poll_controller = &spider_net_poll_controller;
+#endif /* CONFIG_NET_POLL_CONTROLLER */
+        /* ethtool ops */
+        netdev->ethtool_ops = &spider_net_ethtool_ops;
+}
+
+/**
+ * spider_net_setup_netdev - initialization of net_device
+ * @card: card structure
+ *
+ * Returns 0 on success or <0 on failure
+ *
+ * spider_net_setup_netdev initializes the net_device structure
+ **/
+static int
+spider_net_setup_netdev(struct spider_net_card *card)
+{
+        int result;
+        struct net_device *netdev = card->netdev;
+        struct device_node *dn;
+        struct sockaddr addr;
+        u8 *mac;
+
+        SET_MODULE_OWNER(netdev);
+        SET_NETDEV_DEV(netdev, &card->pdev->dev);
+
+        pci_set_drvdata(card->pdev, netdev);
+        spin_lock_init(&card->intmask_lock);
+        netdev->irq = card->pdev->irq;
+
+        card->options.rx_csum = SPIDER_NET_RX_CSUM_DEFAULT;
+
+        spider_net_setup_netdev_ops(netdev);
+
+        netdev->features = 0;
+        /* some time: NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX |
+         *              NETIF_F_HW_VLAN_FILTER */
+
+        netdev->irq = card->pdev->irq;
+
+        dn = pci_device_to_OF_node(card->pdev);
+        if (!dn)
+                return -EIO;
+
+        mac = (u8 *)get_property(dn, "local-mac-address", NULL);
+        if (!mac)
+                return -EIO;
+        memcpy(addr.sa_data, mac, ETH_ALEN);
+
+        result = spider_net_set_mac(netdev, &addr);
+        if ((result) && (netif_msg_probe(card)))
+                pr_err("Failed to set MAC address: %i\n", result);
+
+        result = register_netdev(netdev);
+        if (result) {
+                if (netif_msg_probe(card))
+                        pr_err("Couldn't register net_device: %i\n",
+                                  result);
+                return result;
+        }
+
+        if (netif_msg_probe(card))
+                pr_info("Initialized device %s.\n", netdev->name);
+
+        return 0;
+}
+
+/**
+ * spider_net_alloc_card - allocates net_device and card structure
+ *
+ * returns the card structure or NULL in case of errors
+ *
+ * the card and net_device structures are linked to each other
+ */
+static struct spider_net_card *
+spider_net_alloc_card(void)
+{
+        struct net_device *netdev;
+        struct spider_net_card *card;
+        size_t alloc_size;
+
+        alloc_size = sizeof (*card) +
+                sizeof (struct spider_net_descr) * rx_descriptors +
+                sizeof (struct spider_net_descr) * tx_descriptors;
+        netdev = alloc_etherdev(alloc_size);
+        if (!netdev)
+                return NULL;
+
+        card = netdev_priv(netdev);
+        card->netdev = netdev;
+        card->msg_enable = SPIDER_NET_DEFAULT_MSG;
+        INIT_WORK(&card->tx_timeout_task, spider_net_tx_timeout_task, netdev);
+        init_waitqueue_head(&card->waitq);
+        atomic_set(&card->tx_timeout_task_counter, 0);
+
+        return card;
+}
+
+/**
+ * spider_net_undo_pci_setup - releases PCI ressources
+ * @card: card structure
+ *
+ * spider_net_undo_pci_setup releases the mapped regions
+ */
+static void
+spider_net_undo_pci_setup(struct spider_net_card *card)
+{
+        iounmap(card->regs);
+        pci_release_regions(card->pdev);
+}
+
+/**
+ * spider_net_setup_pci_dev - sets up the device in terms of PCI operations
+ * @card: card structure
+ * @pdev: PCI device
+ *
+ * Returns the card structure or NULL if any errors occur
+ *
+ * spider_net_setup_pci_dev initializes pdev and together with the
+ * functions called in spider_net_open configures the device so that
+ * data can be transferred over it
+ * The net_device structure is attached to the card structure, if the
+ * function returns without error.
+ **/
+static struct spider_net_card *
+spider_net_setup_pci_dev(struct pci_dev *pdev)
+{
+        struct spider_net_card *card;
+        unsigned long mmio_start, mmio_len;
+
+        if (pci_enable_device(pdev)) {
+                pr_err("Couldn't enable PCI device\n");
+                return NULL;
+        }
+
+        if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
+                pr_err("Couldn't find proper PCI device base address.\n");
+                goto out_disable_dev;
+        }
+
+        if (pci_request_regions(pdev, spider_net_driver_name)) {
+                pr_err("Couldn't obtain PCI resources, aborting.\n");
+                goto out_disable_dev;
+        }
+
+        pci_set_master(pdev);
+
+        card = spider_net_alloc_card();
+        if (!card) {
+                pr_err("Couldn't allocate net_device structure, "
+                          "aborting.\n");
+                goto out_release_regions;
+        }
+        card->pdev = pdev;
+
+        /* fetch base address and length of first resource */
+        mmio_start = pci_resource_start(pdev, 0);
+        mmio_len = pci_resource_len(pdev, 0);
+
+        card->netdev->mem_start = mmio_start;
+        card->netdev->mem_end = mmio_start + mmio_len;
+        card->regs = ioremap(mmio_start, mmio_len);
+
+        if (!card->regs) {
+                pr_err("Couldn't obtain PCI resources, aborting.\n");
+                goto out_release_regions;
+        }
+
+        return card;
+
+out_release_regions:
+        pci_release_regions(pdev);
+out_disable_dev:
+        pci_disable_device(pdev);
+        pci_set_drvdata(pdev, NULL);
+        return NULL;
+}
+
+/**
+ * spider_net_probe - initialization of a device
+ * @pdev: PCI device
+ * @ent: entry in the device id list
+ *
+ * Returns 0 on success, <0 on failure
+ *
+ * spider_net_probe initializes pdev and registers a net_device
+ * structure for it. After that, the device can be ifconfig'ed up
+ **/
+static int __devinit
+spider_net_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        int err = -EIO;
+        struct spider_net_card *card;
+
+        card = spider_net_setup_pci_dev(pdev);
+        if (!card)
+                goto out;
+
+        spider_net_workaround_rxramfull(card);
+        spider_net_init_card(card);
+
+        err = spider_net_setup_phy(card);
+        if (err)
+                goto out_undo_pci;
+
+        err = spider_net_init_firmware(card);
+        if (err)
+                goto out_undo_pci;
+
+        err = spider_net_setup_netdev(card);
+        if (err)
+                goto out_undo_pci;
+
+        return 0;
+
+out_undo_pci:
+        spider_net_undo_pci_setup(card);
+        free_netdev(card->netdev);
+out:
+        return err;
+}
+
+/**
+ * spider_net_remove - removal of a device
+ * @pdev: PCI device
+ *
+ * Returns 0 on success, <0 on failure
+ *
+ * spider_net_remove is called to remove the device and unregisters the
+ * net_device
+ **/
+static void __devexit
+spider_net_remove(struct pci_dev *pdev)
+{
+        struct net_device *netdev;
+        struct spider_net_card *card;
+
+        netdev = pci_get_drvdata(pdev);
+        card = netdev_priv(netdev);
+
+        wait_event(card->waitq,
+                   atomic_read(&card->tx_timeout_task_counter) == 0);
+
+        unregister_netdev(netdev);
+
+        /* switch off card */
+        spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
+                             SPIDER_NET_CKRCTRL_STOP_VALUE);
+        spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
+                             SPIDER_NET_CKRCTRL_RUN_VALUE);
+
+        spider_net_undo_pci_setup(card);
+        free_netdev(netdev);
+}
+
+static struct pci_driver spider_net_driver = {
+        .owner          = THIS_MODULE,
+        .name           = spider_net_driver_name,
+        .id_table       = spider_net_pci_tbl,
+        .probe          = spider_net_probe,
+        .remove         = __devexit_p(spider_net_remove)
+};
+
+/**
+ * spider_net_init - init function when the driver is loaded
+ *
+ * spider_net_init registers the device driver
+ */
+static int __init spider_net_init(void)
+{
+        if (rx_descriptors < SPIDER_NET_RX_DESCRIPTORS_MIN) {
+                rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_MIN;
+                pr_info("adjusting rx descriptors to %i.\n", rx_descriptors);
+        }
+        if (rx_descriptors > SPIDER_NET_RX_DESCRIPTORS_MAX) {
+                rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_MAX;
+                pr_info("adjusting rx descriptors to %i.\n", rx_descriptors);
+        }
+        if (tx_descriptors < SPIDER_NET_TX_DESCRIPTORS_MIN) {
+                tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_MIN;
+                pr_info("adjusting tx descriptors to %i.\n", tx_descriptors);
+        }
+        if (tx_descriptors > SPIDER_NET_TX_DESCRIPTORS_MAX) {
+                tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_MAX;
+                pr_info("adjusting tx descriptors to %i.\n", tx_descriptors);
+        }
+
+        return pci_register_driver(&spider_net_driver);
+}
+
+/**
+ * spider_net_cleanup - exit function when driver is unloaded
+ *
+ * spider_net_cleanup unregisters the device driver
+ */
+static void __exit spider_net_cleanup(void)
+{
+        pci_unregister_driver(&spider_net_driver);
+}
+
+module_init(spider_net_init);
+module_exit(spider_net_cleanup);
diff --git a/drivers/net/spider_net.h b/drivers/net/spider_net.h
new file mode 100644
index 000000000000..22b2f2347351
--- /dev/null
+++ b/drivers/net/spider_net.h
@@ -0,0 +1,469 @@
+/*
+ * Network device driver for Cell Processor-Based Blade
+ *
+ * (C) Copyright IBM Corp. 2005
+ *
+ * Authors : Utz Bacher <utz.bacher@de.ibm.com>
+ *           Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _SPIDER_NET_H
+#define _SPIDER_NET_H
+
+#include "sungem_phy.h"
+
+extern int spider_net_stop(struct net_device *netdev);
+extern int spider_net_open(struct net_device *netdev);
+
+extern struct ethtool_ops spider_net_ethtool_ops;
+
+extern char spider_net_driver_name[];
+
+#define SPIDER_NET_MAX_MTU                      2308
+#define SPIDER_NET_MIN_MTU                      64
+
+#define SPIDER_NET_RXBUF_ALIGN                  128
+
+#define SPIDER_NET_RX_DESCRIPTORS_DEFAULT       64
+#define SPIDER_NET_RX_DESCRIPTORS_MIN           16
+#define SPIDER_NET_RX_DESCRIPTORS_MAX           256
+
+#define SPIDER_NET_TX_DESCRIPTORS_DEFAULT       64
+#define SPIDER_NET_TX_DESCRIPTORS_MIN           16
+#define SPIDER_NET_TX_DESCRIPTORS_MAX           256
+
+#define SPIDER_NET_RX_CSUM_DEFAULT              1
+
+#define SPIDER_NET_WATCHDOG_TIMEOUT 5*HZ
+#define SPIDER_NET_NAPI_WEIGHT 64
+
+#define SPIDER_NET_FIRMWARE_LEN         1024
+#define SPIDER_NET_FIRMWARE_NAME        "spider_fw.bin"
+
+/** spider_net SMMIO registers */
+#define SPIDER_NET_GHIINT0STS           0x00000000
+#define SPIDER_NET_GHIINT1STS           0x00000004
+#define SPIDER_NET_GHIINT2STS           0x00000008
+#define SPIDER_NET_GHIINT0MSK           0x00000010
+#define SPIDER_NET_GHIINT1MSK           0x00000014
+#define SPIDER_NET_GHIINT2MSK           0x00000018
+
+#define SPIDER_NET_GRESUMINTNUM         0x00000020
+#define SPIDER_NET_GREINTNUM            0x00000024
+
+#define SPIDER_NET_GFFRMNUM             0x00000028
+#define SPIDER_NET_GFAFRMNUM            0x0000002c
+#define SPIDER_NET_GFBFRMNUM            0x00000030
+#define SPIDER_NET_GFCFRMNUM            0x00000034
+#define SPIDER_NET_GFDFRMNUM            0x00000038
+
+/* clear them (don't use it) */
+#define SPIDER_NET_GFREECNNUM           0x0000003c
+#define SPIDER_NET_GONETIMENUM          0x00000040
+
+#define SPIDER_NET_GTOUTFRMNUM          0x00000044
+
+#define SPIDER_NET_GTXMDSET             0x00000050
+#define SPIDER_NET_GPCCTRL              0x00000054
+#define SPIDER_NET_GRXMDSET             0x00000058
+#define SPIDER_NET_GIPSECINIT           0x0000005c
+#define SPIDER_NET_GFTRESTRT            0x00000060
+#define SPIDER_NET_GRXDMAEN             0x00000064
+#define SPIDER_NET_GMRWOLCTRL           0x00000068
+#define SPIDER_NET_GPCWOPCMD            0x0000006c
+#define SPIDER_NET_GPCROPCMD            0x00000070
+#define SPIDER_NET_GTTFRMCNT            0x00000078
+#define SPIDER_NET_GTESTMD              0x0000007c
+
+#define SPIDER_NET_GSINIT               0x00000080
+#define SPIDER_NET_GSnPRGADR            0x00000084
+#define SPIDER_NET_GSnPRGDAT            0x00000088
+
+#define SPIDER_NET_GMACOPEMD            0x00000100
+#define SPIDER_NET_GMACLENLMT           0x00000108
+#define SPIDER_NET_GMACINTEN            0x00000118
+#define SPIDER_NET_GMACPHYCTRL          0x00000120
+
+#define SPIDER_NET_GMACAPAUSE           0x00000154
+#define SPIDER_NET_GMACTXPAUSE          0x00000164
+
+#define SPIDER_NET_GMACMODE             0x000001b0
+#define SPIDER_NET_GMACBSTLMT           0x000001b4
+
+#define SPIDER_NET_GMACUNIMACU          0x000001c0
+#define SPIDER_NET_GMACUNIMACL          0x000001c8
+
+#define SPIDER_NET_GMRMHFILnR           0x00000400
+#define SPIDER_NET_MULTICAST_HASHES     256
+
+#define SPIDER_NET_GMRUAFILnR           0x00000500
+#define SPIDER_NET_GMRUA0FIL15R         0x00000578
+
+/* RX DMA controller registers, all 0x00000a.. are for DMA controller A,
+ * 0x00000b.. for DMA controller B, etc. */
+#define SPIDER_NET_GDADCHA              0x00000a00
+#define SPIDER_NET_GDADMACCNTR          0x00000a04
+#define SPIDER_NET_GDACTDPA             0x00000a08
+#define SPIDER_NET_GDACTDCNT            0x00000a0c
+#define SPIDER_NET_GDACDBADDR           0x00000a20
+#define SPIDER_NET_GDACDBSIZE           0x00000a24
+#define SPIDER_NET_GDACNEXTDA           0x00000a28
+#define SPIDER_NET_GDACCOMST            0x00000a2c
+#define SPIDER_NET_GDAWBCOMST           0x00000a30
+#define SPIDER_NET_GDAWBRSIZE           0x00000a34
+#define SPIDER_NET_GDAWBVSIZE           0x00000a38
+#define SPIDER_NET_GDAWBTRST            0x00000a3c
+#define SPIDER_NET_GDAWBTRERR           0x00000a40
+
+/* TX DMA controller registers */
+#define SPIDER_NET_GDTDCHA              0x00000e00
+#define SPIDER_NET_GDTDMACCNTR          0x00000e04
+#define SPIDER_NET_GDTCDPA              0x00000e08
+#define SPIDER_NET_GDTDMASEL            0x00000e14
+
+#define SPIDER_NET_ECMODE               0x00000f00
+/* clock and reset control register */
+#define SPIDER_NET_CKRCTRL              0x00000ff0
+
+/** SCONFIG registers */
+#define SPIDER_NET_SCONFIG_IOACTE       0x00002810
+
+/** hardcoded register values */
+#define SPIDER_NET_INT0_MASK_VALUE      0x3f7fe3ff
+#define SPIDER_NET_INT1_MASK_VALUE      0xffffffff
+/* no MAC aborts -> auto retransmission */
+#define SPIDER_NET_INT2_MASK_VALUE      0xfffffff1
+
+/* clear counter when interrupt sources are cleared
+#define SPIDER_NET_FRAMENUM_VALUE       0x0001f001 */
+/* we rely on flagged descriptor interrupts */
+#define SPIDER_NET_FRAMENUM_VALUE       0x00000000
+/* set this first, then the FRAMENUM_VALUE */
+#define SPIDER_NET_GFXFRAMES_VALUE      0x00000000
+
+#define SPIDER_NET_STOP_SEQ_VALUE       0x00000000
+#define SPIDER_NET_RUN_SEQ_VALUE        0x0000007e
+
+#define SPIDER_NET_PHY_CTRL_VALUE       0x00040040
+/* #define SPIDER_NET_PHY_CTRL_VALUE    0x01070080*/
+#define SPIDER_NET_RXMODE_VALUE         0x00000011
+/* auto retransmission in case of MAC aborts */
+#define SPIDER_NET_TXMODE_VALUE         0x00010000
+#define SPIDER_NET_RESTART_VALUE        0x00000000
+#define SPIDER_NET_WOL_VALUE            0x00001111
+#if 0
+#define SPIDER_NET_WOL_VALUE            0x00000000
+#endif
+#define SPIDER_NET_IPSECINIT_VALUE      0x00f000f8
+
+/* pause frames: automatic, no upper retransmission count */
+/* outside loopback mode: ETOMOD signal dont matter, not connected */
+#define SPIDER_NET_OPMODE_VALUE         0x00000063
+/*#define SPIDER_NET_OPMODE_VALUE               0x001b0062*/
+#define SPIDER_NET_LENLMT_VALUE         0x00000908
+
+#define SPIDER_NET_MACAPAUSE_VALUE      0x00000800 /* about 1 ms */
+#define SPIDER_NET_TXPAUSE_VALUE        0x00000000
+
+#define SPIDER_NET_MACMODE_VALUE        0x00000001
+#define SPIDER_NET_BURSTLMT_VALUE       0x00000200 /* about 16 us */
+
+/* 1(0)                                 enable r/tx dma
+ *  0000000                             fixed to 0
+ *
+ *         000000                       fixed to 0
+ *               0(1)                   en/disable descr writeback on force end
+ *                0(1)                  force end
+ *
+ *                 000000               fixed to 0
+ *                       00             burst alignment: 128 bytes
+ *
+ *                         00000        fixed to 0
+ *                              0       descr writeback size 32 bytes
+ *                               0(1)   descr chain end interrupt enable
+ *                                0(1)  descr status writeback enable */
+
+/* to set RX_DMA_EN */
+#define SPIDER_NET_DMA_RX_VALUE         0x80000000
+#define SPIDER_NET_DMA_RX_FEND_VALUE    0x00030003
+/* to set TX_DMA_EN */
+#define SPIDER_NET_DMA_TX_VALUE         0x80000000
+#define SPIDER_NET_DMA_TX_FEND_VALUE    0x00030003
+
+/* SPIDER_NET_UA_DESCR_VALUE is OR'ed with the unicast address */
+#define SPIDER_NET_UA_DESCR_VALUE       0x00080000
+#define SPIDER_NET_PROMISC_VALUE        0x00080000
+#define SPIDER_NET_NONPROMISC_VALUE     0x00000000
+
+#define SPIDER_NET_DMASEL_VALUE         0x00000001
+
+#define SPIDER_NET_ECMODE_VALUE         0x00000000
+
+#define SPIDER_NET_CKRCTRL_RUN_VALUE    0x1fff010f
+#define SPIDER_NET_CKRCTRL_STOP_VALUE   0x0000010f
+
+#define SPIDER_NET_SBIMSTATE_VALUE      0x00000000
+#define SPIDER_NET_SBTMSTATE_VALUE      0x00000000
+
+/* SPIDER_NET_GHIINT0STS bits, in reverse order so that they can be used
+ * with 1 << SPIDER_NET_... */
+enum spider_net_int0_status {
+        SPIDER_NET_GPHYINT = 0,
+        SPIDER_NET_GMAC2INT,
+        SPIDER_NET_GMAC1INT,
+        SPIDER_NET_GIPSINT,
+        SPIDER_NET_GFIFOINT,
+        SPIDER_NET_GDMACINT,
+        SPIDER_NET_GSYSINT,
+        SPIDER_NET_GPWOPCMPINT,
+        SPIDER_NET_GPROPCMPINT,
+        SPIDER_NET_GPWFFINT,
+        SPIDER_NET_GRMDADRINT,
+        SPIDER_NET_GRMARPINT,
+        SPIDER_NET_GRMMPINT,
+        SPIDER_NET_GDTDEN0INT,
+        SPIDER_NET_GDDDEN0INT,
+        SPIDER_NET_GDCDEN0INT,
+        SPIDER_NET_GDBDEN0INT,
+        SPIDER_NET_GDADEN0INT,
+        SPIDER_NET_GDTFDCINT,
+        SPIDER_NET_GDDFDCINT,
+        SPIDER_NET_GDCFDCINT,
+        SPIDER_NET_GDBFDCINT,
+        SPIDER_NET_GDAFDCINT,
+        SPIDER_NET_GTTEDINT,
+        SPIDER_NET_GDTDCEINT,
+        SPIDER_NET_GRFDNMINT,
+        SPIDER_NET_GRFCNMINT,
+        SPIDER_NET_GRFBNMINT,
+        SPIDER_NET_GRFANMINT,
+        SPIDER_NET_GRFNMINT,
+        SPIDER_NET_G1TMCNTINT,
+        SPIDER_NET_GFREECNTINT
+};
+/* GHIINT1STS bits */
+enum spider_net_int1_status {
+        SPIDER_NET_GTMFLLINT = 0,
+        SPIDER_NET_GRMFLLINT,
+        SPIDER_NET_GTMSHTINT,
+        SPIDER_NET_GDTINVDINT,
+        SPIDER_NET_GRFDFLLINT,
+        SPIDER_NET_GDDDCEINT,
+        SPIDER_NET_GDDINVDINT,
+        SPIDER_NET_GRFCFLLINT,
+        SPIDER_NET_GDCDCEINT,
+        SPIDER_NET_GDCINVDINT,
+        SPIDER_NET_GRFBFLLINT,
+        SPIDER_NET_GDBDCEINT,
+        SPIDER_NET_GDBINVDINT,
+        SPIDER_NET_GRFAFLLINT,
+        SPIDER_NET_GDADCEINT,
+        SPIDER_NET_GDAINVDINT,
+        SPIDER_NET_GDTRSERINT,
+        SPIDER_NET_GDDRSERINT,
+        SPIDER_NET_GDCRSERINT,
+        SPIDER_NET_GDBRSERINT,
+        SPIDER_NET_GDARSERINT,
+        SPIDER_NET_GDSERINT,
+        SPIDER_NET_GDTPTERINT,
+        SPIDER_NET_GDDPTERINT,
+        SPIDER_NET_GDCPTERINT,
+        SPIDER_NET_GDBPTERINT,
+        SPIDER_NET_GDAPTERINT
+};
+/* GHIINT2STS bits */
+enum spider_net_int2_status {
+        SPIDER_NET_GPROPERINT = 0,
+        SPIDER_NET_GMCTCRSNGINT,
+        SPIDER_NET_GMCTLCOLINT,
+        SPIDER_NET_GMCTTMOTINT,
+        SPIDER_NET_GMCRCAERINT,
+        SPIDER_NET_GMCRCALERINT,
+        SPIDER_NET_GMCRALNERINT,
+        SPIDER_NET_GMCROVRINT,
+        SPIDER_NET_GMCRRNTINT,
+        SPIDER_NET_GMCRRXERINT,
+        SPIDER_NET_GTITCSERINT,
+        SPIDER_NET_GTIFMTERINT,
+        SPIDER_NET_GTIPKTRVKINT,
+        SPIDER_NET_GTISPINGINT,
+        SPIDER_NET_GTISADNGINT,
+        SPIDER_NET_GTISPDNGINT,
+        SPIDER_NET_GRIFMTERINT,
+        SPIDER_NET_GRIPKTRVKINT,
+        SPIDER_NET_GRISPINGINT,
+        SPIDER_NET_GRISADNGINT,
+        SPIDER_NET_GRISPDNGINT
+};
+
+#define SPIDER_NET_TXINT        ( (1 << SPIDER_NET_GTTEDINT) | \
+                                  (1 << SPIDER_NET_GDTDCEINT) | \
+                                  (1 << SPIDER_NET_GDTFDCINT) )
+
+/* we rely on flagged descriptor interrupts*/
+#define SPIDER_NET_RXINT        ( (1 << SPIDER_NET_GDAFDCINT) | \
+                                  (1 << SPIDER_NET_GRMFLLINT) )
+
+#define SPIDER_NET_GPREXEC              0x80000000
+#define SPIDER_NET_GPRDAT_MASK          0x0000ffff
+
+/* descriptor bits
+ *
+ * 1010                                 descriptor ready
+ *     0                                descr in middle of chain
+ *      000                             fixed to 0
+ *
+ *         0                            no interrupt on completion
+ *          000                         fixed to 0
+ *             1                        no ipsec processing
+ *              1                       last descriptor for this frame
+ *               00                     no checksum
+ *               10                     tcp checksum
+ *               11                     udp checksum
+ *
+ *                 00                   fixed to 0
+ *                   0                  fixed to 0
+ *                    0                 no interrupt on response errors
+ *                     0                no interrupt on invalid descr
+ *                      0               no interrupt on dma process termination
+ *                       0              no interrupt on descr chain end
+ *                        0             no interrupt on descr complete
+ *
+ *                         000          fixed to 0
+ *                            0         response error interrupt status
+ *                             0        invalid descr status
+ *                              0       dma termination status
+ *                               0      descr chain end status
+ *                                0     descr complete status */
+#define SPIDER_NET_DMAC_CMDSTAT_NOCS    0xa00c0000
+#define SPIDER_NET_DMAC_CMDSTAT_TCPCS   0xa00e0000
+#define SPIDER_NET_DMAC_CMDSTAT_UDPCS   0xa00f0000
+#define SPIDER_NET_DESCR_IND_PROC_SHIFT 28
+#define SPIDER_NET_DESCR_IND_PROC_MASKO 0x0fffffff
+
+/* descr ready, descr is in middle of chain, get interrupt on completion */
+#define SPIDER_NET_DMAC_RX_CARDOWNED    0xa0800000
+
+/* multicast is no problem */
+#define SPIDER_NET_DATA_ERROR_MASK      0xffffbfff
+
+enum spider_net_descr_status {
+        SPIDER_NET_DESCR_COMPLETE               = 0x00, /* used in rx and tx */
+        SPIDER_NET_DESCR_RESPONSE_ERROR         = 0x01, /* used in rx and tx */
+        SPIDER_NET_DESCR_PROTECTION_ERROR       = 0x02, /* used in rx and tx */
+        SPIDER_NET_DESCR_FRAME_END              = 0x04, /* used in rx */
+        SPIDER_NET_DESCR_FORCE_END              = 0x05, /* used in rx and tx */
+        SPIDER_NET_DESCR_CARDOWNED              = 0x0a, /* used in rx and tx */
+        SPIDER_NET_DESCR_NOT_IN_USE /* any other value */
+};
+
+struct spider_net_descr {
+        /* as defined by the hardware */
+        dma_addr_t buf_addr;
+        u32 buf_size;
+        dma_addr_t next_descr_addr;
+        u32 dmac_cmd_status;
+        u32 result_size;
+        u32 valid_size; /* all zeroes for tx */
+        u32 data_status;
+        u32 data_error; /* all zeroes for tx */
+
+        /* used in the driver */
+        struct sk_buff *skb;
+        dma_addr_t bus_addr;
+        struct spider_net_descr *next;
+        struct spider_net_descr *prev;
+} __attribute__((aligned(32)));
+
+struct spider_net_descr_chain {
+        /* we walk from tail to head */
+        struct spider_net_descr *head;
+        struct spider_net_descr *tail;
+};
+
+/* descriptor data_status bits */
+#define SPIDER_NET_RXIPCHK              29
+#define SPIDER_NET_TCPUDPIPCHK          28
+#define SPIDER_NET_DATA_STATUS_CHK_MASK (1 << SPIDER_NET_RXIPCHK | \
+                                         1 << SPIDER_NET_TCPUDPIPCHK)
+
+#define SPIDER_NET_VLAN_PACKET          21
+
+/* descriptor data_error bits */
+#define SPIDER_NET_RXIPCHKERR           27
+#define SPIDER_NET_RXTCPCHKERR          26
+#define SPIDER_NET_DATA_ERROR_CHK_MASK  (1 << SPIDER_NET_RXIPCHKERR | \
+                                         1 << SPIDER_NET_RXTCPCHKERR)
+
+/* the cases we don't pass the packet to the stack */
+#define SPIDER_NET_DESTROY_RX_FLAGS     0x70138000
+
+#define SPIDER_NET_DESCR_SIZE           32
+
+/* this will be bigger some time */
+struct spider_net_options {
+        int rx_csum; /* for rx: if 0 ip_summed=NONE,
+                        if 1 and hw has verified, ip_summed=UNNECESSARY */
+};
+
+#define SPIDER_NET_DEFAULT_MSG          ( NETIF_MSG_DRV | \
+                                          NETIF_MSG_PROBE | \
+                                          NETIF_MSG_LINK | \
+                                          NETIF_MSG_TIMER | \
+                                          NETIF_MSG_IFDOWN | \
+                                          NETIF_MSG_IFUP | \
+                                          NETIF_MSG_RX_ERR | \
+                                          NETIF_MSG_TX_ERR | \
+                                          NETIF_MSG_TX_QUEUED | \
+                                          NETIF_MSG_INTR | \
+                                          NETIF_MSG_TX_DONE | \
+                                          NETIF_MSG_RX_STATUS | \
+                                          NETIF_MSG_PKTDATA | \
+                                          NETIF_MSG_HW | \
+                                          NETIF_MSG_WOL )
+
+struct spider_net_card {
+        struct net_device *netdev;
+        struct pci_dev *pdev;
+        struct mii_phy phy;
+
+        void __iomem *regs;
+
+        struct spider_net_descr_chain tx_chain;
+        struct spider_net_descr_chain rx_chain;
+        spinlock_t chain_lock;
+
+        struct net_device_stats netdev_stats;
+
+        struct spider_net_options options;
+
+        spinlock_t intmask_lock;
+
+        struct work_struct tx_timeout_task;
+        atomic_t tx_timeout_task_counter;
+        wait_queue_head_t waitq;
+
+        /* for ethtool */
+        int msg_enable;
+
+        struct spider_net_descr descr[0];
+};
+
+#define pr_err(fmt,arg...) \
+        printk(KERN_ERR fmt ,##arg)
+
+#endif
diff --git a/drivers/net/spider_net_ethtool.c b/drivers/net/spider_net_ethtool.c
new file mode 100644
index 000000000000..d42e60ba74ce
--- /dev/null
+++ b/drivers/net/spider_net_ethtool.c
@@ -0,0 +1,126 @@
+/*
+ * Network device driver for Cell Processor-Based Blade
+ *
+ * (C) Copyright IBM Corp. 2005
+ *
+ * Authors : Utz Bacher <utz.bacher@de.ibm.com>
+ *           Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/pci.h>
+
+#include "spider_net.h"
+
+static int
+spider_net_ethtool_get_settings(struct net_device *netdev,
+                               struct ethtool_cmd *cmd)
+{
+        struct spider_net_card *card;
+        card = netdev_priv(netdev);
+
+        cmd->supported   = (SUPPORTED_1000baseT_Full |
+                             SUPPORTED_FIBRE);
+        cmd->advertising = (ADVERTISED_1000baseT_Full |
+                             ADVERTISED_FIBRE);
+        cmd->port = PORT_FIBRE;
+        cmd->speed = card->phy.speed;
+        cmd->duplex = DUPLEX_FULL;
+
+        return 0;
+}
+
+static void
+spider_net_ethtool_get_drvinfo(struct net_device *netdev,
+                               struct ethtool_drvinfo *drvinfo)
+{
+        struct spider_net_card *card;
+        card = netdev_priv(netdev);
+
+        /* clear and fill out info */
+        memset(drvinfo, 0, sizeof(struct ethtool_drvinfo));
+        strncpy(drvinfo->driver, spider_net_driver_name, 32);
+        strncpy(drvinfo->version, "0.1", 32);
+        strcpy(drvinfo->fw_version, "no information");
+        strncpy(drvinfo->bus_info, pci_name(card->pdev), 32);
+}
+
+static void
+spider_net_ethtool_get_wol(struct net_device *netdev,
+                           struct ethtool_wolinfo *wolinfo)
+{
+        /* no support for wol */
+        wolinfo->supported = 0;
+        wolinfo->wolopts = 0;
+}
+
+static u32
+spider_net_ethtool_get_msglevel(struct net_device *netdev)
+{
+        struct spider_net_card *card;
+        card = netdev_priv(netdev);
+        return card->msg_enable;
+}
+
+static void
+spider_net_ethtool_set_msglevel(struct net_device *netdev,
+                                u32 level)
+{
+        struct spider_net_card *card;
+        card = netdev_priv(netdev);
+        card->msg_enable = level;
+}
+
+static int
+spider_net_ethtool_nway_reset(struct net_device *netdev)
+{
+        if (netif_running(netdev)) {
+                spider_net_stop(netdev);
+                spider_net_open(netdev);
+        }
+        return 0;
+}
+
+static u32
+spider_net_ethtool_get_rx_csum(struct net_device *netdev)
+{
+        struct spider_net_card *card = netdev->priv;
+
+        return card->options.rx_csum;
+}
+
+static int
+spider_net_ethtool_set_rx_csum(struct net_device *netdev, u32 n)
+{
+        struct spider_net_card *card = netdev->priv;
+
+        card->options.rx_csum = n;
+        return 0;
+}
+
+struct ethtool_ops spider_net_ethtool_ops = {
+        .get_settings           = spider_net_ethtool_get_settings,
+        .get_drvinfo            = spider_net_ethtool_get_drvinfo,
+        .get_wol                = spider_net_ethtool_get_wol,
+        .get_msglevel           = spider_net_ethtool_get_msglevel,
+        .set_msglevel           = spider_net_ethtool_set_msglevel,
+        .nway_reset             = spider_net_ethtool_nway_reset,
+        .get_rx_csum            = spider_net_ethtool_get_rx_csum,
+        .set_rx_csum            = spider_net_ethtool_set_rx_csum,
+};
+
diff --git a/drivers/net/sun3lance.c b/drivers/net/sun3lance.c
index 1f43bbfbc1c7..5c8fcd40ef4d 100644
--- a/drivers/net/sun3lance.c
+++ b/drivers/net/sun3lance.c
@@ -162,7 +162,7 @@ struct lance_private {
 #define MEM     lp->mem
 #define DREG    lp->iobase[0]
 #define AREG    lp->iobase[1]
-#define REGA(a) ( AREG = (a), DREG )
+#define REGA(a) (*( AREG = (a), &DREG ))
 
 /* Definitions for the Lance */
 
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index dbcb5a8a2194..2be65d308fbe 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -3258,7 +3258,7 @@ badrx:
                                 wstats.noise = apriv->wstats.qual.noise;
                                 wstats.updated = IW_QUAL_LEVEL_UPDATED
                                         | IW_QUAL_QUAL_UPDATED
-                                        | IW_QUAL_NOISE_UPDATED;
+                                        | IW_QUAL_DBM;
                                 /* Update spy records */
                                 wireless_spy_update(dev, sa, &wstats);
                         }
@@ -3604,7 +3604,7 @@ void mpi_receive_802_11 (struct airo_info *ai)
                 wstats.noise = ai->wstats.qual.noise;
                 wstats.updated = IW_QUAL_QUAL_UPDATED
                         | IW_QUAL_LEVEL_UPDATED
-                        | IW_QUAL_NOISE_UPDATED;
+                        | IW_QUAL_DBM;
                 /* Update spy records */
                 wireless_spy_update(ai->dev, sa, &wstats);
         }
@@ -6489,22 +6489,20 @@ static int airo_get_range(struct net_device *dev,
                 range->max_qual.qual = 100;     /* % */
         else
                 range->max_qual.qual = airo_get_max_quality(&cap_rid);
-        range->max_qual.level = 0;      /* 0 means we use dBm  */
-        range->max_qual.noise = 0;
-        range->max_qual.updated = 0;
+        range->max_qual.level = 0x100 - 120;    /* -120 dBm */
+        range->max_qual.noise = 0x100 - 120;    /* -120 dBm */
 
         /* Experimental measurements - boundary 11/5.5 Mb/s */
         /* Note : with or without the (local->rssi), results
          * are somewhat different. - Jean II */
         if (local->rssi) {
-                range->avg_qual.qual = 50;      /* % */
-                range->avg_qual.level = 186;    /* -70 dBm */
+                range->avg_qual.qual = 50;              /* % */
+                range->avg_qual.level = 0x100 - 70;     /* -70 dBm */
         } else {
                 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
-                range->avg_qual.level = 176;    /* -80 dBm */
+                range->avg_qual.level = 0x100 - 80;     /* -80 dBm */
         }
-        range->avg_qual.noise = 0;
-        range->avg_qual.updated = 0;
+        range->avg_qual.noise = 0x100 - 85;             /* -85 dBm */
 
         for(i = 0 ; i < 8 ; i++) {
                 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
@@ -6727,15 +6725,17 @@ static int airo_get_aplist(struct net_device *dev,
                 if (local->rssi) {
                         qual[i].level = 0x100 - BSSList.dBm;
                         qual[i].qual = airo_dbm_to_pct( local->rssi, BSSList.dBm );
-                        qual[i].updated = IW_QUAL_QUAL_UPDATED;
+                        qual[i].updated = IW_QUAL_QUAL_UPDATED
+                                        | IW_QUAL_LEVEL_UPDATED
+                                        | IW_QUAL_DBM;
                 } else {
                         qual[i].level = (BSSList.dBm + 321) / 2;
                         qual[i].qual = 0;
-                        qual[i].updated = IW_QUAL_QUAL_INVALID;
+                        qual[i].updated = IW_QUAL_QUAL_INVALID
+                                        | IW_QUAL_LEVEL_UPDATED
+                                        | IW_QUAL_DBM;
                 }
                 qual[i].noise = local->wstats.qual.noise;
-                qual[i].updated = IW_QUAL_LEVEL_UPDATED
-                                | IW_QUAL_NOISE_UPDATED;
                 if (BSSList.index == 0xffff)
                         break;
         }
@@ -6861,15 +6861,17 @@ static inline char *airo_translate_scan(struct net_device *dev,
         if (ai->rssi) {
                 iwe.u.qual.level = 0x100 - bss->dBm;
                 iwe.u.qual.qual = airo_dbm_to_pct( ai->rssi, bss->dBm );
-                iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED;
+                iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
+                                | IW_QUAL_LEVEL_UPDATED
+                                | IW_QUAL_DBM;
         } else {
                 iwe.u.qual.level = (bss->dBm + 321) / 2;
                 iwe.u.qual.qual = 0;
-                iwe.u.qual.updated = IW_QUAL_QUAL_INVALID;
+                iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
+                                | IW_QUAL_LEVEL_UPDATED
+                                | IW_QUAL_DBM;
         }
         iwe.u.qual.noise = ai->wstats.qual.noise;
-        iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED
-                        | IW_QUAL_NOISE_UPDATED;
         current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
 
         /* Add encryption capability */
@@ -7222,13 +7224,12 @@ static void airo_read_wireless_stats(struct airo_info *local)
                 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
                 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
         }
-        local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED;
         if (status_rid.len >= 124) {
                 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
-                local->wstats.qual.updated |= IW_QUAL_NOISE_UPDATED;
+                local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
         } else {
                 local->wstats.qual.noise = 0;
-                local->wstats.qual.updated |= IW_QUAL_NOISE_INVALID;
+                local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
         }
 
         /* Packets discarded in the wireless adapter due to wireless
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index f48a6e729224..587869d86eee 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -1593,7 +1593,6 @@ struct net_device *init_atmel_card( unsigned short irq, int port, const AtmelFWT
         dev->set_mac_address = atmel_set_mac_address;
         dev->hard_start_xmit = start_tx;
         dev->get_stats = atmel_get_stats;
-        dev->get_wireless_stats = atmel_get_wireless_stats;
         dev->wireless_handlers = (struct iw_handler_def *)&atmel_handler_def;
         dev->do_ioctl = atmel_ioctl;
         dev->irq = irq;
@@ -2411,7 +2410,8 @@ static const struct iw_handler_def	atmel_handler_def =
         .num_private_args = sizeof(atmel_private_args)/sizeof(struct iw_priv_args), 
         .standard       = (iw_handler *) atmel_handler,
         .private        = (iw_handler *) atmel_private_handler, 
-        .private_args   = (struct iw_priv_args *) atmel_private_args
+        .private_args   = (struct iw_priv_args *) atmel_private_args,
+        .get_wireless_stats = atmel_get_wireless_stats
 };
 
 static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
@@ -2424,19 +2424,6 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         char domain[REGDOMAINSZ+1];
 
         switch (cmd) {
-        case SIOCGIWPRIV:
-                if(wrq->u.data.pointer) {
-                        /* Set the number of ioctl available */
-                        wrq->u.data.length = sizeof(atmel_private_args) / sizeof(atmel_private_args[0]);
-                        
-                        /* Copy structure to the user buffer */
-                        if (copy_to_user(wrq->u.data.pointer,
-                                         (u_char *) atmel_private_args,
-                                         sizeof(atmel_private_args)))
-                                rc = -EFAULT;
-                }
-                break;
-
         case ATMELIDIFC:
                 wrq->u.param.value = ATMELMAGIC;                
                 break;
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index 2a3bd607a5cd..b7f275c00de3 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -72,7 +72,8 @@ static void ipw_rx_queue_replenish(void *);
 static int ipw_up(struct ipw_priv *);
 static void ipw_down(struct ipw_priv *);
 static int ipw_config(struct ipw_priv *);
-static int init_supported_rates(struct ipw_priv *priv, struct ipw_supported_rates *prates);
+static int init_supported_rates(struct ipw_priv *priv,
+                                struct ipw_supported_rates *prates);
 
 static u8 band_b_active_channel[MAX_B_CHANNELS] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0
@@ -102,7 +103,7 @@ static int is_valid_channel(int mode_mask, int channel)
 }
 
 static char *snprint_line(char *buf, size_t count,
-                          const u8 *data, u32 len, u32 ofs)
+                          const u8 * data, u32 len, u32 ofs)
 {
         int out, i, j, l;
         char c;
@@ -136,7 +137,7 @@ static char *snprint_line(char *buf, size_t count,
         return buf;
 }
 
-static void printk_buf(int level, const u8 *data, u32 len)
+static void printk_buf(int level, const u8 * data, u32 len)
 {
         char line[81];
         u32 ofs = 0;
@@ -161,21 +162,24 @@ static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
 {
-        IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(b), (u32)(c));
+        IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
+                     __LINE__, (u32) (b), (u32) (c));
         _ipw_write_reg8(a, b, c);
 }
 
 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
 {
-        IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(b), (u32)(c));
+        IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
+                     __LINE__, (u32) (b), (u32) (c));
         _ipw_write_reg16(a, b, c);
 }
 
 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
 {
-        IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(b), (u32)(c));
+        IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
+                     __LINE__, (u32) (b), (u32) (c));
         _ipw_write_reg32(a, b, c);
 }
 
@@ -195,24 +199,30 @@ static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
  _ipw_write32(ipw, ofs, val)
 
 #define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
-static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs) {
-        IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32)(ofs));
+static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
+{
+        IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
         return _ipw_read8(ipw, ofs);
 }
+
 #define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
 
 #define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
-static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs) {
-        IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32)(ofs));
+static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
+{
+        IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
         return _ipw_read16(ipw, ofs);
 }
+
 #define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
 
 #define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
-static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs) {
-        IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32)(ofs));
+static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
+{
+        IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
         return _ipw_read32(ipw, ofs);
 }
+
 #define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
 
 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
@@ -220,34 +230,30 @@ static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
         IPW_DEBUG_IO("%s %d: read_inddirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
         _ipw_read_indirect(a, b, c, d)
 
-static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 *data, int num);
+static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
+                                int num);
 #define ipw_write_indirect(a, b, c, d) \
         IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
         _ipw_write_indirect(a, b, c, d)
 
 /* indirect write s */
-static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg,
-                             u32 value)
+static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
 {
-        IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n",
-                     priv, reg, value);
+        IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
         _ipw_write32(priv, CX2_INDIRECT_ADDR, reg);
         _ipw_write32(priv, CX2_INDIRECT_DATA, value);
 }
 
-
 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
 {
         IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
         _ipw_write32(priv, CX2_INDIRECT_ADDR, reg & CX2_INDIRECT_ADDR_MASK);
         _ipw_write8(priv, CX2_INDIRECT_DATA, value);
         IPW_DEBUG_IO(" reg = 0x%8lX : value = 0x%8X\n",
-                     (unsigned long)(priv->hw_base + CX2_INDIRECT_DATA),
-                     value);
+                     (unsigned long)(priv->hw_base + CX2_INDIRECT_DATA), value);
 }
 
-static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg,
-                             u16 value)
+static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
 {
         IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
         _ipw_write32(priv, CX2_INDIRECT_ADDR, reg & CX2_INDIRECT_ADDR_MASK);
@@ -262,7 +268,7 @@ static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
         _ipw_write32(priv, CX2_INDIRECT_ADDR, reg & CX2_INDIRECT_ADDR_MASK);
         IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
         word = _ipw_read32(priv, CX2_INDIRECT_DATA);
-        return (word >> ((reg & 0x3)*8)) & 0xff;
+        return (word >> ((reg & 0x3) * 8)) & 0xff;
 }
 
 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
@@ -302,7 +308,7 @@ static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
         _ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr);
         aligned_len = num & CX2_INDIRECT_ADDR_MASK;
         for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
-                *(u32*)buf = ipw_read32(priv, CX2_AUTOINC_DATA);
+                *(u32 *) buf = ipw_read32(priv, CX2_AUTOINC_DATA);
 
         /* Copy the last nibble */
         dif_len = num - aligned_len;
@@ -311,7 +317,7 @@ static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
                 *buf = ipw_read8(priv, CX2_INDIRECT_DATA + i);
 }
 
-static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 *buf,
+static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
                                 int num)
 {
         u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK;
@@ -335,7 +341,7 @@ static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 *buf,
         _ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr);
         aligned_len = num & CX2_INDIRECT_ADDR_MASK;
         for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
-                _ipw_write32(priv, CX2_AUTOINC_DATA, *(u32*)buf);
+                _ipw_write32(priv, CX2_AUTOINC_DATA, *(u32 *) buf);
 
         /* Copy the last nibble */
         dif_len = num - aligned_len;
@@ -428,20 +434,18 @@ static void ipw_dump_nic_error_log(struct ipw_priv *priv)
         }
 
         for (i = ERROR_START_OFFSET;
-             i <= count * ERROR_ELEM_SIZE;
-             i += ERROR_ELEM_SIZE) {
-                desc   = ipw_read_reg32(priv, base + i);
-                time   = ipw_read_reg32(priv, base + i + 1*sizeof(u32));
-                blink1 = ipw_read_reg32(priv, base + i + 2*sizeof(u32));
-                blink2 = ipw_read_reg32(priv, base + i + 3*sizeof(u32));
-                ilink1 = ipw_read_reg32(priv, base + i + 4*sizeof(u32));
-                ilink2 = ipw_read_reg32(priv, base + i + 5*sizeof(u32));
-                idata =  ipw_read_reg32(priv, base + i + 6*sizeof(u32));
+             i <= count * ERROR_ELEM_SIZE; i += ERROR_ELEM_SIZE) {
+                desc = ipw_read_reg32(priv, base + i);
+                time = ipw_read_reg32(priv, base + i + 1 * sizeof(u32));
+                blink1 = ipw_read_reg32(priv, base + i + 2 * sizeof(u32));
+                blink2 = ipw_read_reg32(priv, base + i + 3 * sizeof(u32));
+                ilink1 = ipw_read_reg32(priv, base + i + 4 * sizeof(u32));
+                ilink2 = ipw_read_reg32(priv, base + i + 5 * sizeof(u32));
+                idata = ipw_read_reg32(priv, base + i + 6 * sizeof(u32));
 
-                IPW_ERROR(
-                        "%s %i 0x%08x  0x%08x  0x%08x  0x%08x  0x%08x\n",
-                        ipw_error_desc(desc), time, blink1, blink2,
-                        ilink1, ilink2, idata);
+                IPW_ERROR("%s %i 0x%08x  0x%08x  0x%08x  0x%08x  0x%08x\n",
+                          ipw_error_desc(desc), time, blink1, blink2,
+                          ilink1, ilink2, idata);
         }
 }
 
@@ -456,11 +460,10 @@ static void ipw_dump_nic_event_log(struct ipw_priv *priv)
                 IPW_ERROR("Start IPW Event Log Dump:\n");
 
         for (i = EVENT_START_OFFSET;
-             i <= count * EVENT_ELEM_SIZE;
-             i += EVENT_ELEM_SIZE) {
+             i <= count * EVENT_ELEM_SIZE; i += EVENT_ELEM_SIZE) {
                 ev = ipw_read_reg32(priv, base + i);
-                time  = ipw_read_reg32(priv, base + i + 1*sizeof(u32));
-                data  = ipw_read_reg32(priv, base + i + 2*sizeof(u32));
+                time = ipw_read_reg32(priv, base + i + 1 * sizeof(u32));
+                data = ipw_read_reg32(priv, base + i + 2 * sizeof(u32));
 
 #ifdef CONFIG_IPW_DEBUG
                 IPW_ERROR("%i\t0x%08x\t%i\n", time, data, ev);
@@ -468,8 +471,7 @@ static void ipw_dump_nic_event_log(struct ipw_priv *priv)
         }
 }
 
-static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val,
-                           u32 *len)
+static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
 {
         u32 addr, field_info, field_len, field_count, total_len;
 
@@ -513,11 +515,11 @@ static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val,
                 }
 
                 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
-                              ord, priv->table0_addr + (ord  << 2));
+                              ord, priv->table0_addr + (ord << 2));
 
                 *len = sizeof(u32);
                 ord <<= 2;
-                *((u32 *)val) = ipw_read32(priv, priv->table0_addr + ord);
+                *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
                 break;
 
         case IPW_ORD_TABLE_1_MASK:
@@ -545,7 +547,8 @@ static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val,
                         return -EINVAL;
                 }
 
-                *((u32 *)val) = ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
+                *((u32 *) val) =
+                    ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
                 *len = sizeof(u32);
                 break;
 
@@ -573,13 +576,16 @@ static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val,
 
                 /* get the second DW of statistics ;
                  * two 16-bit words - first is length, second is count */
-                field_info = ipw_read_reg32(priv, priv->table2_addr + (ord << 3) + sizeof(u32));
+                field_info =
+                    ipw_read_reg32(priv,
+                                   priv->table2_addr + (ord << 3) +
+                                   sizeof(u32));
 
                 /* get each entry length */
-                field_len = *((u16 *)&field_info);
+                field_len = *((u16 *) & field_info);
 
                 /* get number of entries */
-                field_count = *(((u16 *)&field_info) + 1);
+                field_count = *(((u16 *) & field_info) + 1);
 
                 /* abort if not enought memory */
                 total_len = field_len * field_count;
@@ -604,7 +610,6 @@ static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val,
 
         }
 
-
         return 0;
 }
 
@@ -624,7 +629,7 @@ static void ipw_init_ordinals(struct ipw_priv *priv)
 
         priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
         priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
-        priv->table2_len &= 0x0000ffff; /* use first two bytes */
+        priv->table2_len &= 0x0000ffff; /* use first two bytes */
 
         IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
                       priv->table2_addr, priv->table2_len);
@@ -643,7 +648,7 @@ static ssize_t show_debug_level(struct device_driver *d, char *buf)
         return sprintf(buf, "0x%08X\n", ipw_debug_level);
 }
 static ssize_t store_debug_level(struct device_driver *d,
-                                const char *buf, size_t count)
+                                 const char *buf, size_t count)
 {
         char *p = (char *)buf;
         u32 val;
@@ -668,11 +673,12 @@ static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
                    show_debug_level, store_debug_level);
 
 static ssize_t show_status(struct device *d,
-                        struct device_attribute *attr, char *buf)
+                           struct device_attribute *attr, char *buf)
 {
         struct ipw_priv *p = d->driver_data;
         return sprintf(buf, "0x%08x\n", (int)p->status);
 }
+
 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 
 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
@@ -681,10 +687,11 @@ static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
         struct ipw_priv *p = d->driver_data;
         return sprintf(buf, "0x%08x\n", (int)p->config);
 }
+
 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
 
 static ssize_t show_nic_type(struct device *d,
-                        struct device_attribute *attr, char *buf)
+                             struct device_attribute *attr, char *buf)
 {
         struct ipw_priv *p = d->driver_data;
         u8 type = p->eeprom[EEPROM_NIC_TYPE];
@@ -704,44 +711,50 @@ static ssize_t show_nic_type(struct device *d,
 
         return sprintf(buf, "UNKNOWN\n");
 }
+
 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
 
 static ssize_t dump_error_log(struct device *d,
-                struct device_attribute *attr, const char *buf, size_t count)
+                              struct device_attribute *attr, const char *buf,
+                              size_t count)
 {
         char *p = (char *)buf;
 
         if (p[0] == '1')
-                ipw_dump_nic_error_log((struct ipw_priv*)d->driver_data);
+                ipw_dump_nic_error_log((struct ipw_priv *)d->driver_data);
 
         return strnlen(buf, count);
 }
+
 static DEVICE_ATTR(dump_errors, S_IWUSR, NULL, dump_error_log);
 
 static ssize_t dump_event_log(struct device *d,
-                struct device_attribute *attr, const char *buf, size_t count)
+                              struct device_attribute *attr, const char *buf,
+                              size_t count)
 {
         char *p = (char *)buf;
 
         if (p[0] == '1')
-                ipw_dump_nic_event_log((struct ipw_priv*)d->driver_data);
+                ipw_dump_nic_event_log((struct ipw_priv *)d->driver_data);
 
         return strnlen(buf, count);
 }
+
 static DEVICE_ATTR(dump_events, S_IWUSR, NULL, dump_event_log);
 
 static ssize_t show_ucode_version(struct device *d,
-                        struct device_attribute *attr, char *buf)
+                                  struct device_attribute *attr, char *buf)
 {
         u32 len = sizeof(u32), tmp = 0;
         struct ipw_priv *p = d->driver_data;
 
-        if(ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
+        if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
                 return 0;
 
         return sprintf(buf, "0x%08x\n", tmp);
 }
-static DEVICE_ATTR(ucode_version, S_IWUSR|S_IRUGO, show_ucode_version, NULL);
+
+static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
 
 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
                         char *buf)
@@ -749,36 +762,38 @@ static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
         u32 len = sizeof(u32), tmp = 0;
         struct ipw_priv *p = d->driver_data;
 
-        if(ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
+        if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
                 return 0;
 
         return sprintf(buf, "0x%08x\n", tmp);
 }
-static DEVICE_ATTR(rtc, S_IWUSR|S_IRUGO, show_rtc, NULL);
+
+static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
 
 /*
  * Add a device attribute to view/control the delay between eeprom
  * operations.
  */
 static ssize_t show_eeprom_delay(struct device *d,
-                        struct device_attribute *attr, char *buf)
+                                 struct device_attribute *attr, char *buf)
 {
-        int n = ((struct ipw_priv*)d->driver_data)->eeprom_delay;
+        int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
         return sprintf(buf, "%i\n", n);
 }
 static ssize_t store_eeprom_delay(struct device *d,
-                        struct device_attribute *attr, const char *buf,
-                        size_t count)
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
 {
         struct ipw_priv *p = d->driver_data;
         sscanf(buf, "%i", &p->eeprom_delay);
         return strnlen(buf, count);
 }
-static DEVICE_ATTR(eeprom_delay, S_IWUSR|S_IRUGO,
-                   show_eeprom_delay,store_eeprom_delay);
+
+static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
+                   show_eeprom_delay, store_eeprom_delay);
 
 static ssize_t show_command_event_reg(struct device *d,
-                        struct device_attribute *attr, char *buf)
+                                      struct device_attribute *attr, char *buf)
 {
         u32 reg = 0;
         struct ipw_priv *p = d->driver_data;
@@ -787,8 +802,8 @@ static ssize_t show_command_event_reg(struct device *d,
         return sprintf(buf, "0x%08x\n", reg);
 }
 static ssize_t store_command_event_reg(struct device *d,
-                                struct device_attribute *attr, const char *buf,
-                                size_t count)
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
 {
         u32 reg;
         struct ipw_priv *p = d->driver_data;
@@ -797,11 +812,12 @@ static ssize_t store_command_event_reg(struct device *d,
         ipw_write_reg32(p, CX2_INTERNAL_CMD_EVENT, reg);
         return strnlen(buf, count);
 }
-static DEVICE_ATTR(command_event_reg, S_IWUSR|S_IRUGO,
-                   show_command_event_reg,store_command_event_reg);
+
+static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
+                   show_command_event_reg, store_command_event_reg);
 
 static ssize_t show_mem_gpio_reg(struct device *d,
-                                struct device_attribute *attr, char *buf)
+                                 struct device_attribute *attr, char *buf)
 {
         u32 reg = 0;
         struct ipw_priv *p = d->driver_data;
@@ -810,8 +826,8 @@ static ssize_t show_mem_gpio_reg(struct device *d,
         return sprintf(buf, "0x%08x\n", reg);
 }
 static ssize_t store_mem_gpio_reg(struct device *d,
-                        struct device_attribute *attr, const char *buf,
-                        size_t count)
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
 {
         u32 reg;
         struct ipw_priv *p = d->driver_data;
@@ -820,11 +836,12 @@ static ssize_t store_mem_gpio_reg(struct device *d,
         ipw_write_reg32(p, 0x301100, reg);
         return strnlen(buf, count);
 }
-static DEVICE_ATTR(mem_gpio_reg, S_IWUSR|S_IRUGO,
-                   show_mem_gpio_reg,store_mem_gpio_reg);
+
+static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
+                   show_mem_gpio_reg, store_mem_gpio_reg);
 
 static ssize_t show_indirect_dword(struct device *d,
-                                struct device_attribute *attr, char *buf)
+                                   struct device_attribute *attr, char *buf)
 {
         u32 reg = 0;
         struct ipw_priv *priv = d->driver_data;
@@ -836,8 +853,8 @@ static ssize_t show_indirect_dword(struct device *d,
         return sprintf(buf, "0x%08x\n", reg);
 }
 static ssize_t store_indirect_dword(struct device *d,
-                                struct device_attribute *attr, const char *buf,
-                                size_t count)
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct ipw_priv *priv = d->driver_data;
 
@@ -845,11 +862,12 @@ static ssize_t store_indirect_dword(struct device *d,
         priv->status |= STATUS_INDIRECT_DWORD;
         return strnlen(buf, count);
 }
-static DEVICE_ATTR(indirect_dword, S_IWUSR|S_IRUGO,
-                   show_indirect_dword,store_indirect_dword);
+
+static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
+                   show_indirect_dword, store_indirect_dword);
 
 static ssize_t show_indirect_byte(struct device *d,
-                        struct device_attribute *attr, char *buf)
+                                  struct device_attribute *attr, char *buf)
 {
         u8 reg = 0;
         struct ipw_priv *priv = d->driver_data;
@@ -861,8 +879,8 @@ static ssize_t show_indirect_byte(struct device *d,
         return sprintf(buf, "0x%02x\n", reg);
 }
 static ssize_t store_indirect_byte(struct device *d,
-                                struct device_attribute *attr, const char *buf,
-                                size_t count)
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
 {
         struct ipw_priv *priv = d->driver_data;
 
@@ -870,11 +888,12 @@ static ssize_t store_indirect_byte(struct device *d,
         priv->status |= STATUS_INDIRECT_BYTE;
         return strnlen(buf, count);
 }
-static DEVICE_ATTR(indirect_byte, S_IWUSR|S_IRUGO,
+
+static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
                    show_indirect_byte, store_indirect_byte);
 
 static ssize_t show_direct_dword(struct device *d,
-                                struct device_attribute *attr, char *buf)
+                                 struct device_attribute *attr, char *buf)
 {
         u32 reg = 0;
         struct ipw_priv *priv = d->driver_data;
@@ -887,8 +906,8 @@ static ssize_t show_direct_dword(struct device *d,
         return sprintf(buf, "0x%08x\n", reg);
 }
 static ssize_t store_direct_dword(struct device *d,
-                        struct device_attribute *attr, const char *buf,
-                        size_t count)
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
 {
         struct ipw_priv *priv = d->driver_data;
 
@@ -896,9 +915,9 @@ static ssize_t store_direct_dword(struct device *d,
         priv->status |= STATUS_DIRECT_DWORD;
         return strnlen(buf, count);
 }
-static DEVICE_ATTR(direct_dword, S_IWUSR|S_IRUGO,
-                   show_direct_dword,store_direct_dword);
 
+static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
+                   show_direct_dword, store_direct_dword);
 
 static inline int rf_kill_active(struct ipw_priv *priv)
 {
@@ -911,7 +930,7 @@ static inline int rf_kill_active(struct ipw_priv *priv)
 }
 
 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
-                                char *buf)
+                            char *buf)
 {
         /* 0 - RF kill not enabled
            1 - SW based RF kill active (sysfs)
@@ -919,7 +938,7 @@ static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
            3 - Both HW and SW baed RF kill active */
         struct ipw_priv *priv = d->driver_data;
         int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
-                (rf_kill_active(priv) ? 0x2 : 0x0);
+            (rf_kill_active(priv) ? 0x2 : 0x0);
         return sprintf(buf, "%i\n", val);
 }
 
@@ -927,7 +946,7 @@ static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
 {
         if ((disable_radio ? 1 : 0) ==
             (priv->status & STATUS_RF_KILL_SW ? 1 : 0))
-                return 0 ;
+                return 0;
 
         IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO  %s\n",
                           disable_radio ? "OFF" : "ON");
@@ -956,8 +975,8 @@ static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
         return 1;
 }
 
-static ssize_t store_rf_kill(struct device *d,  struct device_attribute *attr,
-                                const char *buf, size_t count)
+static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
+                             const char *buf, size_t count)
 {
         struct ipw_priv *priv = d->driver_data;
 
@@ -965,7 +984,8 @@ static ssize_t store_rf_kill(struct device *d,  struct device_attribute *attr,
 
         return count;
 }
-static DEVICE_ATTR(rf_kill, S_IWUSR|S_IRUGO, show_rf_kill, store_rf_kill);
+
+static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
 
 static void ipw_irq_tasklet(struct ipw_priv *priv)
 {
@@ -990,7 +1010,7 @@ static void ipw_irq_tasklet(struct ipw_priv *priv)
 
         if (inta & CX2_INTA_BIT_TX_CMD_QUEUE) {
                 IPW_DEBUG_HC("Command completed.\n");
-                rc = ipw_queue_tx_reclaim( priv, &priv->txq_cmd, -1);
+                rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
                 priv->status &= ~STATUS_HCMD_ACTIVE;
                 wake_up_interruptible(&priv->wait_command_queue);
                 handled |= CX2_INTA_BIT_TX_CMD_QUEUE;
@@ -998,25 +1018,25 @@ static void ipw_irq_tasklet(struct ipw_priv *priv)
 
         if (inta & CX2_INTA_BIT_TX_QUEUE_1) {
                 IPW_DEBUG_TX("TX_QUEUE_1\n");
-                rc = ipw_queue_tx_reclaim( priv, &priv->txq[0], 0);
+                rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
                 handled |= CX2_INTA_BIT_TX_QUEUE_1;
         }
 
         if (inta & CX2_INTA_BIT_TX_QUEUE_2) {
                 IPW_DEBUG_TX("TX_QUEUE_2\n");
-                rc = ipw_queue_tx_reclaim( priv, &priv->txq[1], 1);
+                rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
                 handled |= CX2_INTA_BIT_TX_QUEUE_2;
         }
 
         if (inta & CX2_INTA_BIT_TX_QUEUE_3) {
                 IPW_DEBUG_TX("TX_QUEUE_3\n");
-                rc = ipw_queue_tx_reclaim( priv, &priv->txq[2], 2);
+                rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
                 handled |= CX2_INTA_BIT_TX_QUEUE_3;
         }
 
         if (inta & CX2_INTA_BIT_TX_QUEUE_4) {
                 IPW_DEBUG_TX("TX_QUEUE_4\n");
-                rc = ipw_queue_tx_reclaim( priv, &priv->txq[3], 3);
+                rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
                 handled |= CX2_INTA_BIT_TX_QUEUE_4;
         }
 
@@ -1074,8 +1094,7 @@ static void ipw_irq_tasklet(struct ipw_priv *priv)
         }
 
         if (handled != inta) {
-                IPW_ERROR("Unhandled INTA bits 0x%08x\n",
-                                inta & ~handled);
+                IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
         }
 
         /* enable all interrupts */
@@ -1143,7 +1162,7 @@ static char *get_cmd_string(u8 cmd)
                 return "UNKNOWN";
         }
 }
-#endif /* CONFIG_IPW_DEBUG */
+#endif                          /* CONFIG_IPW_DEBUG */
 
 #define HOST_COMPLETE_TIMEOUT HZ
 static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
@@ -1159,15 +1178,16 @@ static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
 
         IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n",
                      get_cmd_string(cmd->cmd), cmd->cmd, cmd->len);
-        printk_buf(IPW_DL_HOST_COMMAND, (u8*)cmd->param, cmd->len);
+        printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
 
         rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
         if (rc)
                 return rc;
 
-        rc = wait_event_interruptible_timeout(
-                priv->wait_command_queue, !(priv->status & STATUS_HCMD_ACTIVE),
-                HOST_COMPLETE_TIMEOUT);
+        rc = wait_event_interruptible_timeout(priv->wait_command_queue,
+                                              !(priv->
+                                                status & STATUS_HCMD_ACTIVE),
+                                              HOST_COMPLETE_TIMEOUT);
         if (rc == 0) {
                 IPW_DEBUG_INFO("Command completion failed out after %dms.\n",
                                jiffies_to_msecs(HOST_COMPLETE_TIMEOUT));
@@ -1215,7 +1235,7 @@ static int ipw_send_system_config(struct ipw_priv *priv,
                 return -1;
         }
 
-        memcpy(&cmd.param,config,sizeof(*config));
+        memcpy(&cmd.param, config, sizeof(*config));
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send SYSTEM_CONFIG command\n");
                 return -1;
@@ -1224,7 +1244,7 @@ static int ipw_send_system_config(struct ipw_priv *priv,
         return 0;
 }
 
-static int ipw_send_ssid(struct ipw_priv *priv, u8 *ssid, int len)
+static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
 {
         struct host_cmd cmd = {
                 .cmd = IPW_CMD_SSID,
@@ -1245,7 +1265,7 @@ static int ipw_send_ssid(struct ipw_priv *priv, u8 *ssid, int len)
         return 0;
 }
 
-static int ipw_send_adapter_address(struct ipw_priv *priv, u8 *mac)
+static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
 {
         struct host_cmd cmd = {
                 .cmd = IPW_CMD_ADAPTER_ADDRESS,
@@ -1284,9 +1304,6 @@ static void ipw_adapter_restart(void *adapter)
         }
 }
 
-
-
-
 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
 
 static void ipw_scan_check(void *data)
@@ -1313,7 +1330,7 @@ static int ipw_send_scan_request_ext(struct ipw_priv *priv,
                 return -1;
         }
 
-        memcpy(&cmd.param,request,sizeof(*request));
+        memcpy(&cmd.param, request, sizeof(*request));
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send SCAN_REQUEST_EXT command\n");
                 return -1;
@@ -1351,7 +1368,7 @@ static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
                 .len = sizeof(struct ipw_sensitivity_calib)
         };
         struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
-                &cmd.param;
+            &cmd.param;
         calib->beacon_rssi_raw = sens;
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send SENSITIVITY CALIB command\n");
@@ -1374,7 +1391,7 @@ static int ipw_send_associate(struct ipw_priv *priv,
                 return -1;
         }
 
-        memcpy(&cmd.param,associate,sizeof(*associate));
+        memcpy(&cmd.param, associate, sizeof(*associate));
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send ASSOCIATE command\n");
                 return -1;
@@ -1396,7 +1413,7 @@ static int ipw_send_supported_rates(struct ipw_priv *priv,
                 return -1;
         }
 
-        memcpy(&cmd.param,rates,sizeof(*rates));
+        memcpy(&cmd.param, rates, sizeof(*rates));
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send SUPPORTED_RATES command\n");
                 return -1;
@@ -1440,7 +1457,7 @@ static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
                 return -1;
         }
 
-        *((u32*)&cmd.param) = phy_off;
+        *((u32 *) & cmd.param) = phy_off;
 
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send CARD_DISABLE command\n");
@@ -1451,8 +1468,7 @@ static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
 }
 #endif
 
-static int ipw_send_tx_power(struct ipw_priv *priv,
-                             struct ipw_tx_power *power)
+static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
 {
         struct host_cmd cmd = {
                 .cmd = IPW_CMD_TX_POWER,
@@ -1464,7 +1480,7 @@ static int ipw_send_tx_power(struct ipw_priv *priv,
                 return -1;
         }
 
-        memcpy(&cmd.param,power,sizeof(*power));
+        memcpy(&cmd.param, power, sizeof(*power));
         if (ipw_send_cmd(priv, &cmd)) {
                 IPW_ERROR("failed to send TX_POWER command\n");
                 return -1;
@@ -1527,7 +1543,7 @@ static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
                 .cmd = IPW_CMD_POWER_MODE,
                 .len = sizeof(u32)
         };
-        u32 *param = (u32*)(&cmd.param);
+        u32 *param = (u32 *) (&cmd.param);
 
         if (!priv) {
                 IPW_ERROR("Invalid args\n");
@@ -1585,67 +1601,67 @@ static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
 }
 
 /* perform a chip select operation */
-static inline void eeprom_cs(struct ipw_priv* priv)
+static inline void eeprom_cs(struct ipw_priv *priv)
 {
-        eeprom_write_reg(priv,0);
-        eeprom_write_reg(priv,EEPROM_BIT_CS);
-        eeprom_write_reg(priv,EEPROM_BIT_CS|EEPROM_BIT_SK);
-        eeprom_write_reg(priv,EEPROM_BIT_CS);
+        eeprom_write_reg(priv, 0);
+        eeprom_write_reg(priv, EEPROM_BIT_CS);
+        eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
+        eeprom_write_reg(priv, EEPROM_BIT_CS);
 }
 
 /* perform a chip select operation */
-static inline void eeprom_disable_cs(struct ipw_priv* priv)
+static inline void eeprom_disable_cs(struct ipw_priv *priv)
 {
-        eeprom_write_reg(priv,EEPROM_BIT_CS);
-        eeprom_write_reg(priv,0);
-        eeprom_write_reg(priv,EEPROM_BIT_SK);
+        eeprom_write_reg(priv, EEPROM_BIT_CS);
+        eeprom_write_reg(priv, 0);
+        eeprom_write_reg(priv, EEPROM_BIT_SK);
 }
 
 /* push a single bit down to the eeprom */
-static inline void eeprom_write_bit(struct ipw_priv *p,u8 bit)
+static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
 {
-        int d = ( bit ? EEPROM_BIT_DI : 0);
-        eeprom_write_reg(p,EEPROM_BIT_CS|d);
-        eeprom_write_reg(p,EEPROM_BIT_CS|d|EEPROM_BIT_SK);
+        int d = (bit ? EEPROM_BIT_DI : 0);
+        eeprom_write_reg(p, EEPROM_BIT_CS | d);
+        eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
 }
 
 /* push an opcode followed by an address down to the eeprom */
-static void eeprom_op(struct ipw_priv* priv, u8 op, u8 addr)
+static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
 {
         int i;
 
         eeprom_cs(priv);
-        eeprom_write_bit(priv,1);
-        eeprom_write_bit(priv,op&2);
-        eeprom_write_bit(priv,op&1);
-        for ( i=7; i>=0; i-- ) {
-                eeprom_write_bit(priv,addr&(1<<i));
+        eeprom_write_bit(priv, 1);
+        eeprom_write_bit(priv, op & 2);
+        eeprom_write_bit(priv, op & 1);
+        for (i = 7; i >= 0; i--) {
+                eeprom_write_bit(priv, addr & (1 << i));
         }
 }
 
 /* pull 16 bits off the eeprom, one bit at a time */
-static u16 eeprom_read_u16(struct ipw_priv* priv, u8 addr)
+static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
 {
         int i;
-        u16 r=0;
+        u16 r = 0;
 
         /* Send READ Opcode */
-        eeprom_op(priv,EEPROM_CMD_READ,addr);
+        eeprom_op(priv, EEPROM_CMD_READ, addr);
 
         /* Send dummy bit */
-        eeprom_write_reg(priv,EEPROM_BIT_CS);
+        eeprom_write_reg(priv, EEPROM_BIT_CS);
 
         /* Read the byte off the eeprom one bit at a time */
-        for ( i=0; i<16; i++ ) {
+        for (i = 0; i < 16; i++) {
                 u32 data = 0;
-                eeprom_write_reg(priv,EEPROM_BIT_CS|EEPROM_BIT_SK);
-                eeprom_write_reg(priv,EEPROM_BIT_CS);
-                data = ipw_read_reg32(priv,FW_MEM_REG_EEPROM_ACCESS);
-                r = (r<<1) | ((data & EEPROM_BIT_DO)?1:0);
+                eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
+                eeprom_write_reg(priv, EEPROM_BIT_CS);
+                data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
+                r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
         }
 
         /* Send another dummy bit */
-        eeprom_write_reg(priv,0);
+        eeprom_write_reg(priv, 0);
         eeprom_disable_cs(priv);
 
         return r;
@@ -1653,9 +1669,9 @@ static u16 eeprom_read_u16(struct ipw_priv* priv, u8 addr)
 
 /* helper function for pulling the mac address out of the private */
 /* data's copy of the eeprom data                                 */
-static void eeprom_parse_mac(struct ipw_priv* priv, u8* mac)
+static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
 {
-        u8* ee = (u8*)priv->eeprom;
+        u8 *ee = (u8 *) priv->eeprom;
         memcpy(mac, &ee[EEPROM_MAC_ADDRESS], 6);
 }
 
@@ -1670,26 +1686,25 @@ static void eeprom_parse_mac(struct ipw_priv* priv, u8* mac)
 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
 {
         int i;
-        u16 *eeprom = (u16 *)priv->eeprom;
+        u16 *eeprom = (u16 *) priv->eeprom;
 
         IPW_DEBUG_TRACE(">>\n");
 
         /* read entire contents of eeprom into private buffer */
-        for ( i=0; i<128; i++ )
-                eeprom[i] = eeprom_read_u16(priv,(u8)i);
+        for (i = 0; i < 128; i++)
+                eeprom[i] = eeprom_read_u16(priv, (u8) i);
 
         /*
            If the data looks correct, then copy it to our private
            copy.  Otherwise let the firmware know to perform the operation
            on it's own
-        */
+         */
         if ((priv->eeprom + EEPROM_VERSION) != 0) {
                 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
 
                 /* write the eeprom data to sram */
-                for( i=0; i<CX2_EEPROM_IMAGE_SIZE; i++ )
-                        ipw_write8(priv, IPW_EEPROM_DATA + i,
-                                   priv->eeprom[i]);
+                for (i = 0; i < CX2_EEPROM_IMAGE_SIZE; i++)
+                        ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
 
                 /* Do not load eeprom data on fatal error or suspend */
                 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
@@ -1703,11 +1718,11 @@ static void ipw_eeprom_init_sram(struct ipw_priv *priv)
         IPW_DEBUG_TRACE("<<\n");
 }
 
-
 static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
 {
         count >>= 2;
-        if (!count) return;
+        if (!count)
+                return;
         _ipw_write32(priv, CX2_AUTOINC_ADDR, start);
         while (count--)
                 _ipw_write32(priv, CX2_AUTOINC_DATA, 0);
@@ -1721,7 +1736,7 @@ static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
 }
 
 static int ipw_fw_dma_enable(struct ipw_priv *priv)
-{ /* start dma engine but no transfers yet*/
+{                               /* start dma engine but no transfers yet */
 
         IPW_DEBUG_FW(">> : \n");
 
@@ -1749,12 +1764,16 @@ static void ipw_fw_dma_abort(struct ipw_priv *priv)
         IPW_DEBUG_FW("<< \n");
 }
 
-static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index, struct command_block *cb)
+static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
+                                          struct command_block *cb)
 {
-        u32 address = CX2_SHARED_SRAM_DMA_CONTROL + (sizeof(struct command_block) * index);
+        u32 address =
+            CX2_SHARED_SRAM_DMA_CONTROL +
+            (sizeof(struct command_block) * index);
         IPW_DEBUG_FW(">> :\n");
 
-        ipw_write_indirect(priv, address, (u8*)cb, (int)sizeof(struct command_block));
+        ipw_write_indirect(priv, address, (u8 *) cb,
+                           (int)sizeof(struct command_block));
 
         IPW_DEBUG_FW("<< :\n");
         return 0;
@@ -1764,17 +1783,20 @@ static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index, stru
 static int ipw_fw_dma_kick(struct ipw_priv *priv)
 {
         u32 control = 0;
-        u32 index=0;
+        u32 index = 0;
 
         IPW_DEBUG_FW(">> :\n");
 
         for (index = 0; index < priv->sram_desc.last_cb_index; index++)
-                ipw_fw_dma_write_command_block(priv, index, &priv->sram_desc.cb_list[index]);
+                ipw_fw_dma_write_command_block(priv, index,
+                                               &priv->sram_desc.cb_list[index]);
 
         /* Enable the DMA in the CSR register */
-        ipw_clear_bit(priv, CX2_RESET_REG,CX2_RESET_REG_MASTER_DISABLED | CX2_RESET_REG_STOP_MASTER);
+        ipw_clear_bit(priv, CX2_RESET_REG,
+                      CX2_RESET_REG_MASTER_DISABLED |
+                      CX2_RESET_REG_STOP_MASTER);
 
-        /* Set the Start bit. */
+        /* Set the Start bit. */
         control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
         ipw_write_reg32(priv, CX2_DMA_I_DMA_CONTROL, control);
 
@@ -1785,25 +1807,25 @@ static int ipw_fw_dma_kick(struct ipw_priv *priv)
 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
 {
         u32 address;
-        u32 register_value=0;
-        u32 cb_fields_address=0;
+        u32 register_value = 0;
+        u32 cb_fields_address = 0;
 
         IPW_DEBUG_FW(">> :\n");
-        address = ipw_read_reg32(priv,CX2_DMA_I_CURRENT_CB);
-        IPW_DEBUG_FW_INFO("Current CB is 0x%x \n",address);
+        address = ipw_read_reg32(priv, CX2_DMA_I_CURRENT_CB);
+        IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
 
         /* Read the DMA Controlor register */
         register_value = ipw_read_reg32(priv, CX2_DMA_I_DMA_CONTROL);
-        IPW_DEBUG_FW_INFO("CX2_DMA_I_DMA_CONTROL is 0x%x \n",register_value);
+        IPW_DEBUG_FW_INFO("CX2_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
 
-        /* Print the CB values*/
+        /* Print the CB values */
         cb_fields_address = address;
         register_value = ipw_read_reg32(priv, cb_fields_address);
-        IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n",register_value);
+        IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
 
         cb_fields_address += sizeof(u32);
         register_value = ipw_read_reg32(priv, cb_fields_address);
-        IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n",register_value);
+        IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
 
         cb_fields_address += sizeof(u32);
         register_value = ipw_read_reg32(priv, cb_fields_address);
@@ -1812,7 +1834,7 @@ static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
 
         cb_fields_address += sizeof(u32);
         register_value = ipw_read_reg32(priv, cb_fields_address);
-        IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n",register_value);
+        IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
 
         IPW_DEBUG_FW(">> :\n");
 }
@@ -1823,13 +1845,13 @@ static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
         u32 current_cb_index = 0;
 
         IPW_DEBUG_FW("<< :\n");
-        current_cb_address= ipw_read_reg32(priv, CX2_DMA_I_CURRENT_CB);
+        current_cb_address = ipw_read_reg32(priv, CX2_DMA_I_CURRENT_CB);
 
-        current_cb_index = (current_cb_address - CX2_SHARED_SRAM_DMA_CONTROL )/
-                sizeof (struct command_block);
+        current_cb_index = (current_cb_address - CX2_SHARED_SRAM_DMA_CONTROL) /
+            sizeof(struct command_block);
 
         IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
-                          current_cb_index, current_cb_address );
+                          current_cb_index, current_cb_address);
 
         IPW_DEBUG_FW(">> :\n");
         return current_cb_index;
@@ -1840,15 +1862,14 @@ static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
                                         u32 src_address,
                                         u32 dest_address,
                                         u32 length,
-                                        int interrupt_enabled,
-                                        int is_last)
+                                        int interrupt_enabled, int is_last)
 {
 
         u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
-                CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
-                CB_DEST_SIZE_LONG;
+            CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
+            CB_DEST_SIZE_LONG;
         struct command_block *cb;
-        u32 last_cb_element=0;
+        u32 last_cb_element = 0;
 
         IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
                           src_address, dest_address, length);
@@ -1861,7 +1882,7 @@ static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
         priv->sram_desc.last_cb_index++;
 
         /* Calculate the new CB control word */
-        if (interrupt_enabled )
+        if (interrupt_enabled)
                 control |= CB_INT_ENABLED;
 
         if (is_last)
@@ -1870,7 +1891,7 @@ static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
         control |= length;
 
         /* Calculate the CB Element's checksum value */
-        cb->status = control ^src_address ^dest_address;
+        cb->status = control ^ src_address ^ dest_address;
 
         /* Copy the Source and Destination addresses */
         cb->dest_addr = dest_address;
@@ -1883,22 +1904,21 @@ static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
 }
 
 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
-                                 u32 src_phys,
-                                 u32 dest_address,
-                                 u32 length)
+                                 u32 src_phys, u32 dest_address, u32 length)
 {
         u32 bytes_left = length;
-        u32 src_offset=0;
-        u32 dest_offset=0;
+        u32 src_offset = 0;
+        u32 dest_offset = 0;
         int status = 0;
         IPW_DEBUG_FW(">> \n");
         IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
                           src_phys, dest_address, length);
         while (bytes_left > CB_MAX_LENGTH) {
-                status = ipw_fw_dma_add_command_block( priv,
-                                                       src_phys + src_offset,
-                                                       dest_address + dest_offset,
-                                                       CB_MAX_LENGTH, 0, 0);
+                status = ipw_fw_dma_add_command_block(priv,
+                                                      src_phys + src_offset,
+                                                      dest_address +
+                                                      dest_offset,
+                                                      CB_MAX_LENGTH, 0, 0);
                 if (status) {
                         IPW_DEBUG_FW_INFO(": Failed\n");
                         return -1;
@@ -1912,18 +1932,18 @@ static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
 
         /* add the buffer tail */
         if (bytes_left > 0) {
-                status = ipw_fw_dma_add_command_block(
-                        priv, src_phys + src_offset,
-                        dest_address + dest_offset,
-                        bytes_left, 0, 0);
+                status =
+                    ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
+                                                 dest_address + dest_offset,
+                                                 bytes_left, 0, 0);
                 if (status) {
                         IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
                         return -1;
                 } else
-                        IPW_DEBUG_FW_INFO(": Adding new cb - the buffer tail\n");
+                        IPW_DEBUG_FW_INFO
+                            (": Adding new cb - the buffer tail\n");
         }
 
-
         IPW_DEBUG_FW("<< \n");
         return 0;
 }
@@ -1937,7 +1957,7 @@ static int ipw_fw_dma_wait(struct ipw_priv *priv)
 
         current_index = ipw_fw_dma_command_block_index(priv);
         IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
-                          (int) priv->sram_desc.last_cb_index);
+                          (int)priv->sram_desc.last_cb_index);
 
         while (current_index < priv->sram_desc.last_cb_index) {
                 udelay(50);
@@ -1955,8 +1975,8 @@ static int ipw_fw_dma_wait(struct ipw_priv *priv)
 
         ipw_fw_dma_abort(priv);
 
-        /*Disable the DMA in the CSR register*/
-        ipw_set_bit(priv, CX2_RESET_REG,
+        /*Disable the DMA in the CSR register */
+        ipw_set_bit(priv, CX2_RESET_REG,
                     CX2_RESET_REG_MASTER_DISABLED | CX2_RESET_REG_STOP_MASTER);
 
         IPW_DEBUG_FW("<< dmaWaitSync \n");
@@ -2011,8 +2031,7 @@ static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
  * image and the caller is handling the memory allocation and clean up.
  */
 
-
-static int ipw_stop_master(struct ipw_priv * priv)
+static int ipw_stop_master(struct ipw_priv *priv)
 {
         int rc;
 
@@ -2071,14 +2090,13 @@ struct fw_chunk {
 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
 #endif
 
-static int ipw_load_ucode(struct ipw_priv *priv, u8 * data,
-                          size_t len)
+static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
 {
         int rc = 0, i, addr;
         u8 cr = 0;
         u16 *image;
 
-        image = (u16 *)data;
+        image = (u16 *) data;
 
         IPW_DEBUG_TRACE(">> \n");
 
@@ -2087,7 +2105,7 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data,
         if (rc < 0)
                 return rc;
 
-//      spin_lock_irqsave(&priv->lock, flags);
+//      spin_lock_irqsave(&priv->lock, flags);
 
         for (addr = CX2_SHARED_LOWER_BOUND;
              addr < CX2_REGISTER_DOMAIN1_END; addr += 4) {
@@ -2099,7 +2117,7 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data,
         /* destroy DMA queues */
         /* reset sequence */
 
-        ipw_write_reg32(priv, CX2_MEM_HALT_AND_RESET ,CX2_BIT_HALT_RESET_ON);
+        ipw_write_reg32(priv, CX2_MEM_HALT_AND_RESET, CX2_BIT_HALT_RESET_ON);
         ipw_arc_release(priv);
         ipw_write_reg32(priv, CX2_MEM_HALT_AND_RESET, CX2_BIT_HALT_RESET_OFF);
         mdelay(1);
@@ -2128,13 +2146,11 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data,
         for (i = 0; i < len / 2; i++)
                 ipw_write_reg16(priv, CX2_BASEBAND_CONTROL_STORE, image[i]);
 
-
         /* enable DINO */
         ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS, 0);
-        ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS,
-                       DINO_ENABLE_SYSTEM );
+        ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
 
-        /* this is where the igx / win driver deveates from the VAP driver.*/
+        /* this is where the igx / win driver deveates from the VAP driver. */
 
         /* wait for alive response */
         for (i = 0; i < 100; i++) {
@@ -2151,25 +2167,24 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data,
 
                 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
                         response_buffer[i] =
-                                ipw_read_reg32(priv,
-                                               CX2_BASEBAND_RX_FIFO_READ);
+                            ipw_read_reg32(priv, CX2_BASEBAND_RX_FIFO_READ);
                 memcpy(&priv->dino_alive, response_buffer,
                        sizeof(priv->dino_alive));
                 if (priv->dino_alive.alive_command == 1
                     && priv->dino_alive.ucode_valid == 1) {
                         rc = 0;
-                        IPW_DEBUG_INFO(
-                                "Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
-                                "of %02d/%02d/%02d %02d:%02d\n",
-                                priv->dino_alive.software_revision,
-                                priv->dino_alive.software_revision,
-                                priv->dino_alive.device_identifier,
-                                priv->dino_alive.device_identifier,
-                                priv->dino_alive.time_stamp[0],
-                                priv->dino_alive.time_stamp[1],
-                                priv->dino_alive.time_stamp[2],
-                                priv->dino_alive.time_stamp[3],
-                                priv->dino_alive.time_stamp[4]);
+                        IPW_DEBUG_INFO
+                            ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
+                             "of %02d/%02d/%02d %02d:%02d\n",
+                             priv->dino_alive.software_revision,
+                             priv->dino_alive.software_revision,
+                             priv->dino_alive.device_identifier,
+                             priv->dino_alive.device_identifier,
+                             priv->dino_alive.time_stamp[0],
+                             priv->dino_alive.time_stamp[1],
+                             priv->dino_alive.time_stamp[2],
+                             priv->dino_alive.time_stamp[3],
+                             priv->dino_alive.time_stamp[4]);
                 } else {
                         IPW_DEBUG_INFO("Microcode is not alive\n");
                         rc = -EINVAL;
@@ -2183,13 +2198,12 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data,
            firmware have problem getting alive resp. */
         ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS, 0);
 
-//      spin_unlock_irqrestore(&priv->lock, flags);
+//      spin_unlock_irqrestore(&priv->lock, flags);
 
         return rc;
 }
 
-static int ipw_load_firmware(struct ipw_priv *priv, u8 * data,
-                             size_t len)
+static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
 {
         int rc = -1;
         int offset = 0;
@@ -2231,7 +2245,7 @@ static int ipw_load_firmware(struct ipw_priv *priv, u8 * data,
                 offset += chunk->length;
         } while (offset < len);
 
-        /* Run the DMA and wait for the answer*/
+        /* Run the DMA and wait for the answer */
         rc = ipw_fw_dma_kick(priv);
         if (rc) {
                 IPW_ERROR("dmaKick Failed\n");
@@ -2243,8 +2257,8 @@ static int ipw_load_firmware(struct ipw_priv *priv, u8 * data,
                 IPW_ERROR("dmaWaitSync Failed\n");
                 goto out;
         }
- out:
-        pci_free_consistent( priv->pci_dev, len, shared_virt, shared_phys);
+      out:
+        pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
         return rc;
 }
 
@@ -2253,7 +2267,7 @@ static int ipw_stop_nic(struct ipw_priv *priv)
 {
         int rc = 0;
 
-        /* stop*/
+        /* stop */
         ipw_write32(priv, CX2_RESET_REG, CX2_RESET_REG_STOP_MASTER);
 
         rc = ipw_poll_bit(priv, CX2_RESET_REG,
@@ -2272,14 +2286,15 @@ static void ipw_start_nic(struct ipw_priv *priv)
 {
         IPW_DEBUG_TRACE(">>\n");
 
-        /* prvHwStartNic  release ARC*/
+        /* prvHwStartNic  release ARC */
         ipw_clear_bit(priv, CX2_RESET_REG,
                       CX2_RESET_REG_MASTER_DISABLED |
                       CX2_RESET_REG_STOP_MASTER |
                       CBD_RESET_REG_PRINCETON_RESET);
 
         /* enable power management */
-        ipw_set_bit(priv, CX2_GP_CNTRL_RW, CX2_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
+        ipw_set_bit(priv, CX2_GP_CNTRL_RW,
+                    CX2_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
 
         IPW_DEBUG_TRACE("<<\n");
 }
@@ -2295,12 +2310,13 @@ static int ipw_init_nic(struct ipw_priv *priv)
         ipw_set_bit(priv, CX2_GP_CNTRL_RW, CX2_GP_CNTRL_BIT_INIT_DONE);
 
         /* low-level PLL activation */
-        ipw_write32(priv, CX2_READ_INT_REGISTER,  CX2_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
+        ipw_write32(priv, CX2_READ_INT_REGISTER,
+                    CX2_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
 
         /* wait for clock stabilization */
         rc = ipw_poll_bit(priv, CX2_GP_CNTRL_RW,
                           CX2_GP_CNTRL_BIT_CLOCK_READY, 250);
-        if (rc < 0 )
+        if (rc < 0)
                 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
 
         /* assert SW reset */
@@ -2315,7 +2331,6 @@ static int ipw_init_nic(struct ipw_priv *priv)
         return 0;
 }
 
-
 /* Call this function from process context, it will sleep in request_firmware.
  * Probe is an ok place to call this from.
  */
@@ -2383,8 +2398,7 @@ static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
                  * to an SKB, so we need to unmap and free potential storage */
                 if (rxq->pool[i].skb != NULL) {
                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
-                                         CX2_RX_BUF_SIZE,
-                                         PCI_DMA_FROMDEVICE);
+                                         CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
                         dev_kfree_skb(rxq->pool[i].skb);
                 }
                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
@@ -2438,12 +2452,12 @@ static int ipw_load(struct ipw_priv *priv)
                         if (rc)
                                 goto error;
 
-                        rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("sniffer"));
+                        rc = ipw_get_fw(priv, &firmware,
+                                        IPW_FW_NAME("sniffer"));
                         break;
 #endif
                 case IW_MODE_INFRA:
-                        rc = ipw_get_fw(priv, &ucode,
-                                        IPW_FW_NAME("bss_ucode"));
+                        rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
                         if (rc)
                                 goto error;
 
@@ -2471,7 +2485,7 @@ static int ipw_load(struct ipw_priv *priv)
                 goto error;
         }
 
- retry:
+      retry:
         /* Ensure interrupts are disabled */
         ipw_write32(priv, CX2_INTA_MASK_R, ~CX2_INTA_MASK_ALL);
         priv->status &= ~STATUS_INT_ENABLED;
@@ -2528,7 +2542,7 @@ static int ipw_load(struct ipw_priv *priv)
         rc = ipw_load_firmware(priv, firmware->data +
                                sizeof(struct fw_header),
                                firmware->size - sizeof(struct fw_header));
-        if (rc < 0 ) {
+        if (rc < 0) {
                 IPW_ERROR("Unable to load firmware\n");
                 goto error;
         }
@@ -2593,7 +2607,7 @@ static int ipw_load(struct ipw_priv *priv)
 #endif
         return 0;
 
- error:
+      error:
         if (priv->rxq) {
                 ipw_rx_queue_free(priv, priv->rxq);
                 priv->rxq = NULL;
@@ -2671,8 +2685,7 @@ static inline int ipw_queue_inc_wrap(int index, int n_bd)
  *                         (not offset within BAR, full address)
  */
 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
-                           int count, u32 read, u32 write,
-                           u32 base, u32 size)
+                           int count, u32 read, u32 write, u32 base, u32 size)
 {
         q->n_bd = count;
 
@@ -2698,8 +2711,7 @@ static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
 
 static int ipw_queue_tx_init(struct ipw_priv *priv,
                              struct clx2_tx_queue *q,
-                             int count, u32 read, u32 write,
-                             u32 base, u32 size)
+                             int count, u32 read, u32 write, u32 base, u32 size)
 {
         struct pci_dev *dev = priv->pci_dev;
 
@@ -2709,10 +2721,11 @@ static int ipw_queue_tx_init(struct ipw_priv *priv,
                 return -ENOMEM;
         }
 
-        q->bd = pci_alloc_consistent(dev,sizeof(q->bd[0])*count, &q->q.dma_addr);
+        q->bd =
+            pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
         if (!q->bd) {
                 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
-                                sizeof(q->bd[0]) * count);
+                          sizeof(q->bd[0]) * count);
                 kfree(q->txb);
                 q->txb = NULL;
                 return -ENOMEM;
@@ -2768,8 +2781,7 @@ static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
  * @param dev
  * @param q
  */
-static void ipw_queue_tx_free(struct ipw_priv *priv,
-                            struct clx2_tx_queue *txq)
+static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
 {
         struct clx2_queue *q = &txq->q;
         struct pci_dev *dev = priv->pci_dev;
@@ -2784,7 +2796,7 @@ static void ipw_queue_tx_free(struct ipw_priv *priv,
         }
 
         /* free buffers belonging to queue itself */
-        pci_free_consistent(dev, sizeof(txq->bd[0])*q->n_bd, txq->bd,
+        pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
                             q->dma_addr);
         kfree(txq->txb);
 
@@ -2792,7 +2804,6 @@ static void ipw_queue_tx_free(struct ipw_priv *priv,
         memset(txq, 0, sizeof(*txq));
 }
 
-
 /**
  * Destroy all DMA queues and structures
  *
@@ -2825,7 +2836,7 @@ static void inline __maybe_wake_tx(struct ipw_priv *priv)
 
 }
 
-static inline void ipw_create_bssid(struct ipw_priv *priv, u8 *bssid)
+static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
 {
         /* First 3 bytes are manufacturer */
         bssid[0] = priv->mac_addr[0];
@@ -2833,13 +2844,13 @@ static inline void ipw_create_bssid(struct ipw_priv *priv, u8 *bssid)
         bssid[2] = priv->mac_addr[2];
 
         /* Last bytes are random */
-        get_random_bytes(&bssid[3], ETH_ALEN-3);
+        get_random_bytes(&bssid[3], ETH_ALEN - 3);
 
-        bssid[0] &= 0xfe;       /* clear multicast bit */
-        bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
+        bssid[0] &= 0xfe;       /* clear multicast bit */
+        bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
 }
 
-static inline u8 ipw_add_station(struct ipw_priv *priv, u8 *bssid)
+static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
 {
         struct ipw_station_entry entry;
         int i;
@@ -2866,14 +2877,13 @@ static inline u8 ipw_add_station(struct ipw_priv *priv, u8 *bssid)
         memcpy(entry.mac_addr, bssid, ETH_ALEN);
         memcpy(priv->stations[i], bssid, ETH_ALEN);
         ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
-                         &entry,
-                         sizeof(entry));
+                         &entry, sizeof(entry));
         priv->num_stations++;
 
         return i;
 }
 
-static inline u8 ipw_find_station(struct ipw_priv *priv, u8 *bssid)
+static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
 {
         int i;
 
@@ -2944,26 +2954,34 @@ static const struct ipw_status_code ipw_status_codes[] = {
          "association exists"},
         {0x0C, "Association denied due to reason outside the scope of this "
          "standard"},
-        {0x0D, "Responding station does not support the specified authentication "
+        {0x0D,
+         "Responding station does not support the specified authentication "
          "algorithm"},
-        {0x0E, "Received an Authentication frame with authentication sequence "
+        {0x0E,
+         "Received an Authentication frame with authentication sequence "
          "transaction sequence number out of expected sequence"},
         {0x0F, "Authentication rejected because of challenge failure"},
         {0x10, "Authentication rejected due to timeout waiting for next "
          "frame in sequence"},
         {0x11, "Association denied because AP is unable to handle additional "
          "associated stations"},
-        {0x12, "Association denied due to requesting station not supporting all "
+        {0x12,
+         "Association denied due to requesting station not supporting all "
          "of the datarates in the BSSBasicServiceSet Parameter"},
-        {0x13, "Association denied due to requesting station not supporting "
+        {0x13,
+         "Association denied due to requesting station not supporting "
          "short preamble operation"},
-        {0x14, "Association denied due to requesting station not supporting "
+        {0x14,
+         "Association denied due to requesting station not supporting "
          "PBCC encoding"},
-        {0x15, "Association denied due to requesting station not supporting "
+        {0x15,
+         "Association denied due to requesting station not supporting "
          "channel agility"},
-        {0x19, "Association denied due to requesting station not supporting "
+        {0x19,
+         "Association denied due to requesting station not supporting "
          "short slot operation"},
-        {0x1A, "Association denied due to requesting station not supporting "
+        {0x1A,
+         "Association denied due to requesting station not supporting "
          "DSSS-OFDM operation"},
         {0x28, "Invalid Information Element"},
         {0x29, "Group Cipher is not valid"},
@@ -3043,7 +3061,6 @@ static void ipw_reset_stats(struct ipw_priv *priv)
 
 }
 
-
 static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
 {
         u32 i = 0x80000000;
@@ -3056,20 +3073,21 @@ static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
         /* TODO: Verify that the rate is supported by the current rates
          * list. */
 
-        while (i && !(mask & i)) i >>= 1;
+        while (i && !(mask & i))
+                i >>= 1;
         switch (i) {
-        case IEEE80211_CCK_RATE_1MB_MASK: return 1000000;
-        case IEEE80211_CCK_RATE_2MB_MASK: return 2000000;
-        case IEEE80211_CCK_RATE_5MB_MASK: return 5500000;
-        case IEEE80211_OFDM_RATE_6MB_MASK: return 6000000;
-        case IEEE80211_OFDM_RATE_9MB_MASK: return 9000000;
-        case IEEE80211_CCK_RATE_11MB_MASK: return 11000000;
-        case IEEE80211_OFDM_RATE_12MB_MASK: return 12000000;
-        case IEEE80211_OFDM_RATE_18MB_MASK: return 18000000;
-        case IEEE80211_OFDM_RATE_24MB_MASK: return 24000000;
-        case IEEE80211_OFDM_RATE_36MB_MASK: return 36000000;
-        case IEEE80211_OFDM_RATE_48MB_MASK: return 48000000;
-        case IEEE80211_OFDM_RATE_54MB_MASK: return 54000000;
+        case IEEE80211_CCK_RATE_1MB_MASK:       return 1000000;
+        case IEEE80211_CCK_RATE_2MB_MASK:       return 2000000;
+        case IEEE80211_CCK_RATE_5MB_MASK:       return 5500000;
+        case IEEE80211_OFDM_RATE_6MB_MASK:      return 6000000;
+        case IEEE80211_OFDM_RATE_9MB_MASK:      return 9000000;
+        case IEEE80211_CCK_RATE_11MB_MASK:      return 11000000;
+        case IEEE80211_OFDM_RATE_12MB_MASK:     return 12000000;
+        case IEEE80211_OFDM_RATE_18MB_MASK:     return 18000000;
+        case IEEE80211_OFDM_RATE_24MB_MASK:     return 24000000;
+        case IEEE80211_OFDM_RATE_36MB_MASK:     return 36000000;
+        case IEEE80211_OFDM_RATE_48MB_MASK:     return 48000000;
+        case IEEE80211_OFDM_RATE_54MB_MASK:     return 54000000;
         }
 
         if (priv->ieee->mode == IEEE_B)
@@ -3097,18 +3115,18 @@ static u32 ipw_get_current_rate(struct ipw_priv *priv)
                 return ipw_get_max_rate(priv);
 
         switch (rate) {
-        case IPW_TX_RATE_1MB:  return  1000000;
-        case IPW_TX_RATE_2MB:  return  2000000;
-        case IPW_TX_RATE_5MB:  return  5500000;
-        case IPW_TX_RATE_6MB:  return  6000000;
-        case IPW_TX_RATE_9MB:  return  9000000;
-        case IPW_TX_RATE_11MB: return 11000000;
-        case IPW_TX_RATE_12MB: return 12000000;
-        case IPW_TX_RATE_18MB: return 18000000;
-        case IPW_TX_RATE_24MB: return 24000000;
-        case IPW_TX_RATE_36MB: return 36000000;
-        case IPW_TX_RATE_48MB: return 48000000;
-        case IPW_TX_RATE_54MB: return 54000000;
+        case IPW_TX_RATE_1MB:   return 1000000;
+        case IPW_TX_RATE_2MB:   return 2000000;
+        case IPW_TX_RATE_5MB:   return 5500000;
+        case IPW_TX_RATE_6MB:   return 6000000;
+        case IPW_TX_RATE_9MB:   return 9000000;
+        case IPW_TX_RATE_11MB:  return 11000000;
+        case IPW_TX_RATE_12MB:  return 12000000;
+        case IPW_TX_RATE_18MB:  return 18000000;
+        case IPW_TX_RATE_24MB:  return 24000000;
+        case IPW_TX_RATE_36MB:  return 36000000;
+        case IPW_TX_RATE_48MB:  return 48000000;
+        case IPW_TX_RATE_54MB:  return 54000000;
         }
 
         return 0;
@@ -3126,7 +3144,7 @@ static void ipw_gather_stats(struct ipw_priv *priv)
         u32 len = sizeof(u32);
         s16 rssi;
         u32 beacon_quality, signal_quality, tx_quality, rx_quality,
-                rate_quality;
+            rate_quality;
 
         if (!(priv->status & STATUS_ASSOCIATED)) {
                 priv->quality = 0;
@@ -3136,13 +3154,12 @@ static void ipw_gather_stats(struct ipw_priv *priv)
         /* Update the statistics */
         ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
                         &priv->missed_beacons, &len);
-        missed_beacons_delta = priv->missed_beacons -
-                priv->last_missed_beacons;
+        missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
         priv->last_missed_beacons = priv->missed_beacons;
         if (priv->assoc_request.beacon_interval) {
                 missed_beacons_percent = missed_beacons_delta *
-                        (HZ * priv->assoc_request.beacon_interval) /
-                        (IPW_STATS_INTERVAL * 10);
+                    (HZ * priv->assoc_request.beacon_interval) /
+                    (IPW_STATS_INTERVAL * 10);
         } else {
                 missed_beacons_percent = 0;
         }
@@ -3179,28 +3196,26 @@ static void ipw_gather_stats(struct ipw_priv *priv)
                 beacon_quality = 0;
         else
                 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
-                        (100 - BEACON_THRESHOLD);
+                    (100 - BEACON_THRESHOLD);
         IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
                         beacon_quality, missed_beacons_percent);
 
         priv->last_rate = ipw_get_current_rate(priv);
-        rate_quality =  priv->last_rate * 40 / priv->last_rate + 60;
+        rate_quality = priv->last_rate * 40 / priv->last_rate + 60;
         IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
                         rate_quality, priv->last_rate / 1000000);
 
-        if (rx_packets_delta > 100 &&
-            rx_packets_delta + rx_err_delta)
+        if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
                 rx_quality = 100 - (rx_err_delta * 100) /
-                        (rx_packets_delta + rx_err_delta);
+                    (rx_packets_delta + rx_err_delta);
         else
                 rx_quality = 100;
         IPW_DEBUG_STATS("Rx quality   : %3d%% (%u errors, %u packets)\n",
                         rx_quality, rx_err_delta, rx_packets_delta);
 
-        if (tx_packets_delta > 100 &&
-            tx_packets_delta + tx_failures_delta)
+        if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
                 tx_quality = 100 - (tx_failures_delta * 100) /
-                        (tx_packets_delta + tx_failures_delta);
+                    (tx_packets_delta + tx_failures_delta);
         else
                 tx_quality = 100;
         IPW_DEBUG_STATS("Tx quality   : %3d%% (%u errors, %u packets)\n",
@@ -3213,7 +3228,7 @@ static void ipw_gather_stats(struct ipw_priv *priv)
                 signal_quality = 0;
         else
                 signal_quality = (rssi - WORST_RSSI) * 100 /
-                        (PERFECT_RSSI - WORST_RSSI);
+                    (PERFECT_RSSI - WORST_RSSI);
         IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
                         signal_quality, rssi);
 
@@ -3221,25 +3236,20 @@ static void ipw_gather_stats(struct ipw_priv *priv)
                       min(rate_quality,
                           min(tx_quality, min(rx_quality, signal_quality))));
         if (quality == beacon_quality)
-                IPW_DEBUG_STATS(
-                        "Quality (%d%%): Clamped to missed beacons.\n",
-                        quality);
+                IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
+                                quality);
         if (quality == rate_quality)
-                IPW_DEBUG_STATS(
-                        "Quality (%d%%): Clamped to rate quality.\n",
-                        quality);
+                IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
+                                quality);
         if (quality == tx_quality)
-                IPW_DEBUG_STATS(
-                        "Quality (%d%%): Clamped to Tx quality.\n",
-                        quality);
+                IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
+                                quality);
         if (quality == rx_quality)
-                IPW_DEBUG_STATS(
-                        "Quality (%d%%): Clamped to Rx quality.\n",
-                        quality);
+                IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
+                                quality);
         if (quality == signal_quality)
-                IPW_DEBUG_STATS(
-                        "Quality (%d%%): Clamped to signal quality.\n",
-                        quality);
+                IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
+                                quality);
 
         priv->quality = quality;
 
@@ -3251,402 +3261,454 @@ static void ipw_gather_stats(struct ipw_priv *priv)
  * Handle host notification packet.
  * Called from interrupt routine
  */
-static inline void ipw_rx_notification(struct ipw_priv* priv,
+static inline void ipw_rx_notification(struct ipw_priv *priv,
                                        struct ipw_rx_notification *notif)
 {
-        IPW_DEBUG_NOTIF("type = %i (%d bytes)\n",
-                        notif->subtype, notif->size);
+        IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
 
         switch (notif->subtype) {
-        case HOST_NOTIFICATION_STATUS_ASSOCIATED: {
-                struct notif_association *assoc = &notif->u.assoc;
-
-                switch (assoc->state) {
-                case CMAS_ASSOCIATED: {
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "associated: '%s' " MAC_FMT " \n",
-                                  escape_essid(priv->essid, priv->essid_len),
-                                  MAC_ARG(priv->bssid));
-
-                        switch (priv->ieee->iw_mode) {
-                        case IW_MODE_INFRA:
-                                memcpy(priv->ieee->bssid, priv->bssid,
-                                       ETH_ALEN);
-                                break;
-
-                        case IW_MODE_ADHOC:
-                                memcpy(priv->ieee->bssid, priv->bssid,
-                                       ETH_ALEN);
-
-                                /* clear out the station table */
-                                priv->num_stations = 0;
-
-                                IPW_DEBUG_ASSOC("queueing adhoc check\n");
-                                queue_delayed_work(priv->workqueue,
-                                                   &priv->adhoc_check,
-                                                   priv->assoc_request.beacon_interval);
-                                break;
-                        }
-
-                        priv->status &= ~STATUS_ASSOCIATING;
-                        priv->status |= STATUS_ASSOCIATED;
-
-                        netif_carrier_on(priv->net_dev);
-                        if (netif_queue_stopped(priv->net_dev)) {
-                                IPW_DEBUG_NOTIF("waking queue\n");
-                                netif_wake_queue(priv->net_dev);
-                        } else {
-                                IPW_DEBUG_NOTIF("starting queue\n");
-                                netif_start_queue(priv->net_dev);
-                        }
-
-                        ipw_reset_stats(priv);
-                        /* Ensure the rate is updated immediately */
-                        priv->last_rate = ipw_get_current_rate(priv);
-                        schedule_work(&priv->gather_stats);
-                        notify_wx_assoc_event(priv);
+        case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
+                        struct notif_association *assoc = &notif->u.assoc;
+
+                        switch (assoc->state) {
+                        case CMAS_ASSOCIATED:{
+                                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                                  IPW_DL_ASSOC,
+                                                  "associated: '%s' " MAC_FMT
+                                                  " \n",
+                                                  escape_essid(priv->essid,
+                                                               priv->essid_len),
+                                                  MAC_ARG(priv->bssid));
+
+                                        switch (priv->ieee->iw_mode) {
+                                        case IW_MODE_INFRA:
+                                                memcpy(priv->ieee->bssid,
+                                                       priv->bssid, ETH_ALEN);
+                                                break;
+
+                                        case IW_MODE_ADHOC:
+                                                memcpy(priv->ieee->bssid,
+                                                       priv->bssid, ETH_ALEN);
+
+                                                /* clear out the station table */
+                                                priv->num_stations = 0;
+
+                                                IPW_DEBUG_ASSOC
+                                                    ("queueing adhoc check\n");
+                                                queue_delayed_work(priv->
+                                                                   workqueue,
+                                                                   &priv->
+                                                                   adhoc_check,
+                                                                   priv->
+                                                                   assoc_request.
+                                                                   beacon_interval);
+                                                break;
+                                        }
+
+                                        priv->status &= ~STATUS_ASSOCIATING;
+                                        priv->status |= STATUS_ASSOCIATED;
+
+                                        netif_carrier_on(priv->net_dev);
+                                        if (netif_queue_stopped(priv->net_dev)) {
+                                                IPW_DEBUG_NOTIF
+                                                    ("waking queue\n");
+                                                netif_wake_queue(priv->net_dev);
+                                        } else {
+                                                IPW_DEBUG_NOTIF
+                                                    ("starting queue\n");
+                                                netif_start_queue(priv->
+                                                                  net_dev);
+                                        }
+
+                                        ipw_reset_stats(priv);
+                                        /* Ensure the rate is updated immediately */
+                                        priv->last_rate =
+                                            ipw_get_current_rate(priv);
+                                        schedule_work(&priv->gather_stats);
+                                        notify_wx_assoc_event(priv);
 
 /*                      queue_delayed_work(priv->workqueue,
                                            &priv->request_scan,
                                            SCAN_ASSOCIATED_INTERVAL);
 */
-                        break;
-                }
+                                        break;
+                                }
 
-                case CMAS_AUTHENTICATED: {
-                        if (priv->status & (STATUS_ASSOCIATED | STATUS_AUTH)) {
+                        case CMAS_AUTHENTICATED:{
+                                        if (priv->
+                                            status & (STATUS_ASSOCIATED |
+                                                      STATUS_AUTH)) {
 #ifdef CONFIG_IPW_DEBUG
-                                struct notif_authenticate *auth = &notif->u.auth;
-                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                          "deauthenticated: '%s' " MAC_FMT ": (0x%04X) - %s \n",
-                                          escape_essid(priv->essid, priv->essid_len),
-                                          MAC_ARG(priv->bssid),
-                                          ntohs(auth->status),
-                                          ipw_get_status_code(ntohs(auth->status)));
+                                                struct notif_authenticate *auth
+                                                    = &notif->u.auth;
+                                                IPW_DEBUG(IPW_DL_NOTIF |
+                                                          IPW_DL_STATE |
+                                                          IPW_DL_ASSOC,
+                                                          "deauthenticated: '%s' "
+                                                          MAC_FMT
+                                                          ": (0x%04X) - %s \n",
+                                                          escape_essid(priv->
+                                                                       essid,
+                                                                       priv->
+                                                                       essid_len),
+                                                          MAC_ARG(priv->bssid),
+                                                          ntohs(auth->status),
+                                                          ipw_get_status_code
+                                                          (ntohs
+                                                           (auth->status)));
 #endif
 
-                                priv->status &= ~(STATUS_ASSOCIATING |
-                                                  STATUS_AUTH |
-                                                  STATUS_ASSOCIATED);
+                                                priv->status &=
+                                                    ~(STATUS_ASSOCIATING |
+                                                      STATUS_AUTH |
+                                                      STATUS_ASSOCIATED);
+
+                                                netif_carrier_off(priv->
+                                                                  net_dev);
+                                                netif_stop_queue(priv->net_dev);
+                                                queue_work(priv->workqueue,
+                                                           &priv->request_scan);
+                                                notify_wx_assoc_event(priv);
+                                                break;
+                                        }
+
+                                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                                  IPW_DL_ASSOC,
+                                                  "authenticated: '%s' " MAC_FMT
+                                                  "\n",
+                                                  escape_essid(priv->essid,
+                                                               priv->essid_len),
+                                                  MAC_ARG(priv->bssid));
+                                        break;
+                                }
+
+                        case CMAS_INIT:{
+                                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                                  IPW_DL_ASSOC,
+                                                  "disassociated: '%s' " MAC_FMT
+                                                  " \n",
+                                                  escape_essid(priv->essid,
+                                                               priv->essid_len),
+                                                  MAC_ARG(priv->bssid));
+
+                                        priv->status &=
+                                            ~(STATUS_DISASSOCIATING |
+                                              STATUS_ASSOCIATING |
+                                              STATUS_ASSOCIATED | STATUS_AUTH);
+
+                                        netif_stop_queue(priv->net_dev);
+                                        if (!(priv->status & STATUS_ROAMING)) {
+                                                netif_carrier_off(priv->
+                                                                  net_dev);
+                                                notify_wx_assoc_event(priv);
+
+                                                /* Cancel any queued work ... */
+                                                cancel_delayed_work(&priv->
+                                                                    request_scan);
+                                                cancel_delayed_work(&priv->
+                                                                    adhoc_check);
+
+                                                /* Queue up another scan... */
+                                                queue_work(priv->workqueue,
+                                                           &priv->request_scan);
+
+                                                cancel_delayed_work(&priv->
+                                                                    gather_stats);
+                                        } else {
+                                                priv->status |= STATUS_ROAMING;
+                                                queue_work(priv->workqueue,
+                                                           &priv->request_scan);
+                                        }
+
+                                        ipw_reset_stats(priv);
+                                        break;
+                                }
 
-                                netif_carrier_off(priv->net_dev);
-                                netif_stop_queue(priv->net_dev);
-                                queue_work(priv->workqueue, &priv->request_scan);
-                                notify_wx_assoc_event(priv);
+                        default:
+                                IPW_ERROR("assoc: unknown (%d)\n",
+                                          assoc->state);
                                 break;
                         }
 
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "authenticated: '%s' " MAC_FMT "\n",
-                                  escape_essid(priv->essid, priv->essid_len),
-                                  MAC_ARG(priv->bssid));
                         break;
                 }
 
-                case CMAS_INIT: {
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "disassociated: '%s' " MAC_FMT " \n",
-                                  escape_essid(priv->essid, priv->essid_len),
-                                  MAC_ARG(priv->bssid));
+        case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
+                        struct notif_authenticate *auth = &notif->u.auth;
+                        switch (auth->state) {
+                        case CMAS_AUTHENTICATED:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
+                                          "authenticated: '%s' " MAC_FMT " \n",
+                                          escape_essid(priv->essid,
+                                                       priv->essid_len),
+                                          MAC_ARG(priv->bssid));
+                                priv->status |= STATUS_AUTH;
+                                break;
 
-                        priv->status &= ~(
-                                STATUS_DISASSOCIATING |
-                                STATUS_ASSOCIATING |
-                                STATUS_ASSOCIATED |
-                                STATUS_AUTH);
+                        case CMAS_INIT:
+                                if (priv->status & STATUS_AUTH) {
+                                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                                  IPW_DL_ASSOC,
+                                                  "authentication failed (0x%04X): %s\n",
+                                                  ntohs(auth->status),
+                                                  ipw_get_status_code(ntohs
+                                                                      (auth->
+                                                                       status)));
+                                }
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC,
+                                          "deauthenticated: '%s' " MAC_FMT "\n",
+                                          escape_essid(priv->essid,
+                                                       priv->essid_len),
+                                          MAC_ARG(priv->bssid));
 
-                        netif_stop_queue(priv->net_dev);
-                        if (!(priv->status & STATUS_ROAMING)) {
-                                netif_carrier_off(priv->net_dev);
-                                notify_wx_assoc_event(priv);
-
-                                /* Cancel any queued work ... */
-                                cancel_delayed_work(&priv->request_scan);
-                                cancel_delayed_work(&priv->adhoc_check);
+                                priv->status &= ~(STATUS_ASSOCIATING |
+                                                  STATUS_AUTH |
+                                                  STATUS_ASSOCIATED);
 
-                                /* Queue up another scan... */
+                                netif_carrier_off(priv->net_dev);
+                                netif_stop_queue(priv->net_dev);
                                 queue_work(priv->workqueue,
                                            &priv->request_scan);
+                                notify_wx_assoc_event(priv);
+                                break;
 
-                                cancel_delayed_work(&priv->gather_stats);
-                        } else {
-                                priv->status |= STATUS_ROAMING;
-                                queue_work(priv->workqueue,
-                                           &priv->request_scan);
+                        case CMAS_TX_AUTH_SEQ_1:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUTH_SEQ_1\n");
+                                break;
+                        case CMAS_RX_AUTH_SEQ_2:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUTH_SEQ_2\n");
+                                break;
+                        case CMAS_AUTH_SEQ_1_PASS:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
+                                break;
+                        case CMAS_AUTH_SEQ_1_FAIL:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
+                                break;
+                        case CMAS_TX_AUTH_SEQ_3:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUTH_SEQ_3\n");
+                                break;
+                        case CMAS_RX_AUTH_SEQ_4:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
+                                break;
+                        case CMAS_AUTH_SEQ_2_PASS:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
+                                break;
+                        case CMAS_AUTH_SEQ_2_FAIL:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
+                                break;
+                        case CMAS_TX_ASSOC:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "TX_ASSOC\n");
+                                break;
+                        case CMAS_RX_ASSOC_RESP:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
+                                break;
+                        case CMAS_ASSOCIATED:
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
+                                          IPW_DL_ASSOC, "ASSOCIATED\n");
+                                break;
+                        default:
+                                IPW_DEBUG_NOTIF("auth: failure - %d\n",
+                                                auth->state);
+                                break;
                         }
-
-                        ipw_reset_stats(priv);
-                        break;
-                }
-
-                default:
-                        IPW_ERROR("assoc: unknown (%d)\n",
-                                  assoc->state);
                         break;
                 }
 
-                break;
-        }
+        case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
+                        struct notif_channel_result *x =
+                            &notif->u.channel_result;
 
-        case HOST_NOTIFICATION_STATUS_AUTHENTICATE: {
-                struct notif_authenticate *auth = &notif->u.auth;
-                switch (auth->state) {
-                case CMAS_AUTHENTICATED:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
-                                  "authenticated: '%s' " MAC_FMT " \n",
-                                  escape_essid(priv->essid, priv->essid_len),
-                                  MAC_ARG(priv->bssid));
-                        priv->status |= STATUS_AUTH;
-                        break;
-
-                case CMAS_INIT:
-                        if (priv->status & STATUS_AUTH) {
-                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                          "authentication failed (0x%04X): %s\n",
-                                          ntohs(auth->status),
-                                          ipw_get_status_code(ntohs(auth->status)));
+                        if (notif->size == sizeof(*x)) {
+                                IPW_DEBUG_SCAN("Scan result for channel %d\n",
+                                               x->channel_num);
+                        } else {
+                                IPW_DEBUG_SCAN("Scan result of wrong size %d "
+                                               "(should be %zd)\n",
+                                               notif->size, sizeof(*x));
                         }
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "deauthenticated: '%s' " MAC_FMT "\n",
-                                  escape_essid(priv->essid, priv->essid_len),
-                                  MAC_ARG(priv->bssid));
-
-                        priv->status &= ~(STATUS_ASSOCIATING |
-                                          STATUS_AUTH |
-                                          STATUS_ASSOCIATED);
-
-                        netif_carrier_off(priv->net_dev);
-                        netif_stop_queue(priv->net_dev);
-                        queue_work(priv->workqueue, &priv->request_scan);
-                        notify_wx_assoc_event(priv);
-                        break;
-
-                case CMAS_TX_AUTH_SEQ_1:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUTH_SEQ_1\n");
-                        break;
-                case CMAS_RX_AUTH_SEQ_2:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUTH_SEQ_2\n");
-                        break;
-                case CMAS_AUTH_SEQ_1_PASS:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUTH_SEQ_1_PASS\n");
-                        break;
-                case CMAS_AUTH_SEQ_1_FAIL:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUTH_SEQ_1_FAIL\n");
-                        break;
-                case CMAS_TX_AUTH_SEQ_3:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUTH_SEQ_3\n");
-                        break;
-                case CMAS_RX_AUTH_SEQ_4:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "RX_AUTH_SEQ_4\n");
-                        break;
-                case CMAS_AUTH_SEQ_2_PASS:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUTH_SEQ_2_PASS\n");
-                        break;
-                case CMAS_AUTH_SEQ_2_FAIL:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "AUT_SEQ_2_FAIL\n");
-                        break;
-                case CMAS_TX_ASSOC:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "TX_ASSOC\n");
-                        break;
-                case CMAS_RX_ASSOC_RESP:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "RX_ASSOC_RESP\n");
-                        break;
-                case CMAS_ASSOCIATED:
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
-                                  "ASSOCIATED\n");
-                        break;
-                default:
-                        IPW_DEBUG_NOTIF("auth: failure - %d\n", auth->state);
                         break;
                 }
-                break;
-        }
-
-        case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT: {
-                struct notif_channel_result *x = &notif->u.channel_result;
-
-                if (notif->size == sizeof(*x)) {
-                        IPW_DEBUG_SCAN("Scan result for channel %d\n",
-                                       x->channel_num);
-                } else {
-                        IPW_DEBUG_SCAN("Scan result of wrong size %d "
-                                       "(should be %zd)\n",
-                                       notif->size, sizeof(*x));
-                }
-                break;
-        }
 
-        case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED: {
-                struct notif_scan_complete* x = &notif->u.scan_complete;
-                if (notif->size == sizeof(*x)) {
-                        IPW_DEBUG_SCAN("Scan completed: type %d, %d channels, "
-                                       "%d status\n",
-                                       x->scan_type,
-                                       x->num_channels,
-                                       x->status);
-                } else {
-                        IPW_ERROR("Scan completed of wrong size %d "
-                                  "(should be %zd)\n",
-                                  notif->size, sizeof(*x));
-                }
-
-                priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
-
-                cancel_delayed_work(&priv->scan_check);
-
-                if (!(priv->status & (STATUS_ASSOCIATED |
-                                      STATUS_ASSOCIATING |
-                                      STATUS_ROAMING |
-                                      STATUS_DISASSOCIATING)))
-                        queue_work(priv->workqueue, &priv->associate);
-                else if (priv->status & STATUS_ROAMING) {
-                        /* If a scan completed and we are in roam mode, then
-                         * the scan that completed was the one requested as a
-                         * result of entering roam... so, schedule the
-                         * roam work */
-                        queue_work(priv->workqueue, &priv->roam);
-                } else if (priv->status & STATUS_SCAN_PENDING)
-                        queue_work(priv->workqueue, &priv->request_scan);
-
-                priv->ieee->scans++;
-                break;
-        }
+        case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
+                        struct notif_scan_complete *x = &notif->u.scan_complete;
+                        if (notif->size == sizeof(*x)) {
+                                IPW_DEBUG_SCAN
+                                    ("Scan completed: type %d, %d channels, "
+                                     "%d status\n", x->scan_type,
+                                     x->num_channels, x->status);
+                        } else {
+                                IPW_ERROR("Scan completed of wrong size %d "
+                                          "(should be %zd)\n",
+                                          notif->size, sizeof(*x));
+                        }
 
-        case HOST_NOTIFICATION_STATUS_FRAG_LENGTH: {
-                struct notif_frag_length *x = &notif->u.frag_len;
+                        priv->status &=
+                            ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
+
+                        cancel_delayed_work(&priv->scan_check);
+
+                        if (!(priv->status & (STATUS_ASSOCIATED |
+                                              STATUS_ASSOCIATING |
+                                              STATUS_ROAMING |
+                                              STATUS_DISASSOCIATING)))
+                                queue_work(priv->workqueue, &priv->associate);
+                        else if (priv->status & STATUS_ROAMING) {
+                                /* If a scan completed and we are in roam mode, then
+                                 * the scan that completed was the one requested as a
+                                 * result of entering roam... so, schedule the
+                                 * roam work */
+                                queue_work(priv->workqueue, &priv->roam);
+                        } else if (priv->status & STATUS_SCAN_PENDING)
+                                queue_work(priv->workqueue,
+                                           &priv->request_scan);
 
-                if (notif->size == sizeof(*x)) {
-                        IPW_ERROR("Frag length: %d\n", x->frag_length);
-                } else {
-                        IPW_ERROR("Frag length of wrong size %d "
-                                  "(should be %zd)\n",
-                                  notif->size, sizeof(*x));
+                        priv->ieee->scans++;
+                        break;
                 }
-                break;
-        }
 
-        case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION: {
-                struct notif_link_deterioration *x =
-                        &notif->u.link_deterioration;
-                if (notif->size==sizeof(*x)) {
-                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
-                                  "link deterioration: '%s' " MAC_FMT " \n",
-                                  escape_essid(priv->essid, priv->essid_len),
-                                  MAC_ARG(priv->bssid));
-                        memcpy(&priv->last_link_deterioration, x, sizeof(*x));
-                } else {
-                        IPW_ERROR("Link Deterioration of wrong size %d "
-                                  "(should be %zd)\n",
-                                  notif->size, sizeof(*x));
-                }
-                break;
-        }
+        case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
+                        struct notif_frag_length *x = &notif->u.frag_len;
 
-        case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE: {
-                IPW_ERROR("Dino config\n");
-                if (priv->hcmd && priv->hcmd->cmd == HOST_CMD_DINO_CONFIG) {
-                        /* TODO: Do anything special? */
-                } else {
-                        IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
+                        if (notif->size == sizeof(*x)) {
+                                IPW_ERROR("Frag length: %d\n", x->frag_length);
+                        } else {
+                                IPW_ERROR("Frag length of wrong size %d "
+                                          "(should be %zd)\n",
+                                          notif->size, sizeof(*x));
+                        }
+                        break;
                 }
-                break;
-        }
 
-        case HOST_NOTIFICATION_STATUS_BEACON_STATE: {
-                struct notif_beacon_state *x = &notif->u.beacon_state;
-                if (notif->size != sizeof(*x)) {
-                        IPW_ERROR("Beacon state of wrong size %d (should "
-                                  "be %zd)\n", notif->size, sizeof(*x));
+        case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
+                        struct notif_link_deterioration *x =
+                            &notif->u.link_deterioration;
+                        if (notif->size == sizeof(*x)) {
+                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
+                                          "link deterioration: '%s' " MAC_FMT
+                                          " \n", escape_essid(priv->essid,
+                                                              priv->essid_len),
+                                          MAC_ARG(priv->bssid));
+                                memcpy(&priv->last_link_deterioration, x,
+                                       sizeof(*x));
+                        } else {
+                                IPW_ERROR("Link Deterioration of wrong size %d "
+                                          "(should be %zd)\n",
+                                          notif->size, sizeof(*x));
+                        }
                         break;
                 }
 
-                if (x->state == HOST_NOTIFICATION_STATUS_BEACON_MISSING) {
-                        if (priv->status & STATUS_SCANNING) {
-                                /* Stop scan to keep fw from getting
-                                 * stuck... */
-                                queue_work(priv->workqueue,
-                                           &priv->abort_scan);
+        case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
+                        IPW_ERROR("Dino config\n");
+                        if (priv->hcmd
+                            && priv->hcmd->cmd == HOST_CMD_DINO_CONFIG) {
+                                /* TODO: Do anything special? */
+                        } else {
+                                IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
                         }
+                        break;
+                }
 
-                        if (x->number > priv->missed_beacon_threshold &&
-                            priv->status & STATUS_ASSOCIATED) {
-                                IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
-                                          IPW_DL_STATE,
-                                          "Missed beacon: %d - disassociate\n",
-                                          x->number);
-                                queue_work(priv->workqueue,
-                                           &priv->disassociate);
-                        } else if (x->number > priv->roaming_threshold) {
-                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
-                                          "Missed beacon: %d - initiate "
-                                          "roaming\n",
-                                          x->number);
-                                queue_work(priv->workqueue,
-                                           &priv->roam);
-                        } else {
-                                IPW_DEBUG_NOTIF("Missed beacon: %d\n",
-                                                x->number);
+        case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
+                        struct notif_beacon_state *x = &notif->u.beacon_state;
+                        if (notif->size != sizeof(*x)) {
+                                IPW_ERROR
+                                    ("Beacon state of wrong size %d (should "
+                                     "be %zd)\n", notif->size, sizeof(*x));
+                                break;
                         }
 
-                        priv->notif_missed_beacons = x->number;
+                        if (x->state == HOST_NOTIFICATION_STATUS_BEACON_MISSING) {
+                                if (priv->status & STATUS_SCANNING) {
+                                        /* Stop scan to keep fw from getting
+                                         * stuck... */
+                                        queue_work(priv->workqueue,
+                                                   &priv->abort_scan);
+                                }
+
+                                if (x->number > priv->missed_beacon_threshold &&
+                                    priv->status & STATUS_ASSOCIATED) {
+                                        IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
+                                                  IPW_DL_STATE,
+                                                  "Missed beacon: %d - disassociate\n",
+                                                  x->number);
+                                        queue_work(priv->workqueue,
+                                                   &priv->disassociate);
+                                } else if (x->number > priv->roaming_threshold) {
+                                        IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
+                                                  "Missed beacon: %d - initiate "
+                                                  "roaming\n", x->number);
+                                        queue_work(priv->workqueue,
+                                                   &priv->roam);
+                                } else {
+                                        IPW_DEBUG_NOTIF("Missed beacon: %d\n",
+                                                        x->number);
+                                }
+
+                                priv->notif_missed_beacons = x->number;
 
-                }
+                        }
 
+                        break;
+                }
 
-                break;
-        }
+        case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
+                        struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
+                        if (notif->size == sizeof(*x)) {
+                                IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
+                                          "0x%02x station %d\n",
+                                          x->key_state, x->security_type,
+                                          x->station_index);
+                                break;
+                        }
 
-        case HOST_NOTIFICATION_STATUS_TGI_TX_KEY: {
-                struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
-                if (notif->size==sizeof(*x)) {
-                        IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
-                                  "0x%02x station %d\n",
-                                  x->key_state,x->security_type,
-                                  x->station_index);
+                        IPW_ERROR
+                            ("TGi Tx Key of wrong size %d (should be %zd)\n",
+                             notif->size, sizeof(*x));
                         break;
                 }
 
-                IPW_ERROR("TGi Tx Key of wrong size %d (should be %zd)\n",
-                          notif->size, sizeof(*x));
-                break;
-        }
+        case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
+                        struct notif_calibration *x = &notif->u.calibration;
 
-        case HOST_NOTIFICATION_CALIB_KEEP_RESULTS: {
-                struct notif_calibration *x = &notif->u.calibration;
+                        if (notif->size == sizeof(*x)) {
+                                memcpy(&priv->calib, x, sizeof(*x));
+                                IPW_DEBUG_INFO("TODO: Calibration\n");
+                                break;
+                        }
 
-                if (notif->size == sizeof(*x)) {
-                        memcpy(&priv->calib, x, sizeof(*x));
-                        IPW_DEBUG_INFO("TODO: Calibration\n");
+                        IPW_ERROR
+                            ("Calibration of wrong size %d (should be %zd)\n",
+                             notif->size, sizeof(*x));
                         break;
                 }
 
-                IPW_ERROR("Calibration of wrong size %d (should be %zd)\n",
-                          notif->size, sizeof(*x));
-                break;
-        }
+        case HOST_NOTIFICATION_NOISE_STATS:{
+                        if (notif->size == sizeof(u32)) {
+                                priv->last_noise =
+                                    (u8) (notif->u.noise.value & 0xff);
+                                average_add(&priv->average_noise,
+                                            priv->last_noise);
+                                break;
+                        }
 
-        case HOST_NOTIFICATION_NOISE_STATS: {
-                if (notif->size == sizeof(u32)) {
-                        priv->last_noise = (u8)(notif->u.noise.value & 0xff);
-                        average_add(&priv->average_noise, priv->last_noise);
+                        IPW_ERROR
+                            ("Noise stat is wrong size %d (should be %zd)\n",
+                             notif->size, sizeof(u32));
                         break;
                 }
 
-                IPW_ERROR("Noise stat is wrong size %d (should be %zd)\n",
-                          notif->size, sizeof(u32));
-                break;
-        }
-
         default:
                 IPW_ERROR("Unknown notification: "
                           "subtype=%d,flags=0x%2x,size=%d\n",
@@ -3680,8 +3742,7 @@ static int ipw_queue_reset(struct ipw_priv *priv)
         rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
                                CX2_TX_QUEUE_0_READ_INDEX,
                                CX2_TX_QUEUE_0_WRITE_INDEX,
-                               CX2_TX_QUEUE_0_BD_BASE,
-                               CX2_TX_QUEUE_0_BD_SIZE);
+                               CX2_TX_QUEUE_0_BD_BASE, CX2_TX_QUEUE_0_BD_SIZE);
         if (rc) {
                 IPW_ERROR("Tx 0 queue init failed\n");
                 goto error;
@@ -3689,8 +3750,7 @@ static int ipw_queue_reset(struct ipw_priv *priv)
         rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
                                CX2_TX_QUEUE_1_READ_INDEX,
                                CX2_TX_QUEUE_1_WRITE_INDEX,
-                               CX2_TX_QUEUE_1_BD_BASE,
-                               CX2_TX_QUEUE_1_BD_SIZE);
+                               CX2_TX_QUEUE_1_BD_BASE, CX2_TX_QUEUE_1_BD_SIZE);
         if (rc) {
                 IPW_ERROR("Tx 1 queue init failed\n");
                 goto error;
@@ -3698,8 +3758,7 @@ static int ipw_queue_reset(struct ipw_priv *priv)
         rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
                                CX2_TX_QUEUE_2_READ_INDEX,
                                CX2_TX_QUEUE_2_WRITE_INDEX,
-                               CX2_TX_QUEUE_2_BD_BASE,
-                               CX2_TX_QUEUE_2_BD_SIZE);
+                               CX2_TX_QUEUE_2_BD_BASE, CX2_TX_QUEUE_2_BD_SIZE);
         if (rc) {
                 IPW_ERROR("Tx 2 queue init failed\n");
                 goto error;
@@ -3707,8 +3766,7 @@ static int ipw_queue_reset(struct ipw_priv *priv)
         rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
                                CX2_TX_QUEUE_3_READ_INDEX,
                                CX2_TX_QUEUE_3_WRITE_INDEX,
-                               CX2_TX_QUEUE_3_BD_BASE,
-                               CX2_TX_QUEUE_3_BD_SIZE);
+                               CX2_TX_QUEUE_3_BD_BASE, CX2_TX_QUEUE_3_BD_SIZE);
         if (rc) {
                 IPW_ERROR("Tx 3 queue init failed\n");
                 goto error;
@@ -3718,7 +3776,7 @@ static int ipw_queue_reset(struct ipw_priv *priv)
         priv->rx_pend_max = 0;
         return rc;
 
- error:
+      error:
         ipw_tx_queue_free(priv);
         return rc;
 }
@@ -3746,8 +3804,8 @@ static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
         hw_tail = ipw_read32(priv, q->reg_r);
         if (hw_tail >= q->n_bd) {
                 IPW_ERROR
-                        ("Read index for DMA queue (%d) is out of range [0-%d)\n",
-                         hw_tail, q->n_bd);
+                    ("Read index for DMA queue (%d) is out of range [0-%d)\n",
+                     hw_tail, q->n_bd);
                 goto done;
         }
         for (; q->last_used != hw_tail;
@@ -3755,7 +3813,7 @@ static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
                 ipw_queue_tx_free_tfd(priv, txq);
                 priv->tx_packets++;
         }
- done:
+      done:
         if (ipw_queue_space(q) > q->low_mark && qindex >= 0) {
                 __maybe_wake_tx(priv);
         }
@@ -3795,8 +3853,6 @@ static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
         return 0;
 }
 
-
-
 /*
  * Rx theory of operation
  *
@@ -3933,9 +3989,9 @@ static void ipw_rx_queue_replenish(void *data)
                 list_del(element);
 
                 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
-                rxb->dma_addr = pci_map_single(
-                        priv->pci_dev, rxb->skb->data, CX2_RX_BUF_SIZE,
-                        PCI_DMA_FROMDEVICE);
+                rxb->dma_addr =
+                    pci_map_single(priv->pci_dev, rxb->skb->data,
+                                   CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
 
                 list_add_tail(&rxb->list, &rxq->rx_free);
                 rxq->free_count++;
@@ -3950,8 +4006,7 @@ static void ipw_rx_queue_replenish(void *data)
  * This free routine walks the list of POOL entries and if SKB is set to
  * non NULL it is unmapped and freed
  */
-static void ipw_rx_queue_free(struct ipw_priv *priv,
-                              struct ipw_rx_queue *rxq)
+static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
 {
         int i;
 
@@ -3961,8 +4016,7 @@ static void ipw_rx_queue_free(struct ipw_priv *priv,
         for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
                 if (rxq->pool[i].skb != NULL) {
                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
-                                         CX2_RX_BUF_SIZE,
-                                         PCI_DMA_FROMDEVICE);
+                                         CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
                         dev_kfree_skb(rxq->pool[i].skb);
                 }
         }
@@ -4001,28 +4055,28 @@ static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
                 switch (rate) {
                 case IEEE80211_OFDM_RATE_6MB:
                         return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
-                                1 : 0;
+                            1 : 0;
                 case IEEE80211_OFDM_RATE_9MB:
                         return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
-                                1 : 0;
+                            1 : 0;
                 case IEEE80211_OFDM_RATE_12MB:
-                        return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ?
-                                1 : 0;
+                        return priv->
+                            rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
                 case IEEE80211_OFDM_RATE_18MB:
-                        return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ?
-                                1 : 0;
+                        return priv->
+                            rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
                 case IEEE80211_OFDM_RATE_24MB:
-                        return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ?
-                                1 : 0;
+                        return priv->
+                            rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
                 case IEEE80211_OFDM_RATE_36MB:
-                        return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ?
-                                1 : 0;
+                        return priv->
+                            rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
                 case IEEE80211_OFDM_RATE_48MB:
-                        return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ?
-                                1 : 0;
+                        return priv->
+                            rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
                 case IEEE80211_OFDM_RATE_54MB:
-                        return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ?
-                                1 : 0;
+                        return priv->
+                            rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
                 default:
                         return 0;
                 }
@@ -4074,10 +4128,11 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
         int num_rates, i;
 
         memset(rates, 0, sizeof(*rates));
-        num_rates = min(network->rates_len, (u8)IPW_MAX_RATES);
+        num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
         rates->num_rates = 0;
         for (i = 0; i < num_rates; i++) {
-                if (!ipw_is_rate_in_mask(priv, network->mode, network->rates[i])) {
+                if (!ipw_is_rate_in_mask
+                    (priv, network->mode, network->rates[i])) {
                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
                                        network->rates[i], priv->rates_mask);
                         continue;
@@ -4086,15 +4141,18 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
                 rates->supported_rates[rates->num_rates++] = network->rates[i];
         }
 
-        num_rates = min(network->rates_ex_len, (u8)(IPW_MAX_RATES - num_rates));
+        num_rates =
+            min(network->rates_ex_len, (u8) (IPW_MAX_RATES - num_rates));
         for (i = 0; i < num_rates; i++) {
-                if (!ipw_is_rate_in_mask(priv, network->mode, network->rates_ex[i])) {
+                if (!ipw_is_rate_in_mask
+                    (priv, network->mode, network->rates_ex[i])) {
                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
                                        network->rates_ex[i], priv->rates_mask);
                         continue;
                 }
 
-                rates->supported_rates[rates->num_rates++] = network->rates_ex[i];
+                rates->supported_rates[rates->num_rates++] =
+                    network->rates_ex[i];
         }
 
         return rates->num_rates;
@@ -4113,65 +4171,65 @@ static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
  * mask should ever be used -- right now all callers to add the scan rates are
  * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
-                               u8 modulation, u32 rate_mask)
+                                   u8 modulation, u32 rate_mask)
 {
         u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
-                IEEE80211_BASIC_RATE_MASK : 0;
+            IEEE80211_BASIC_RATE_MASK : 0;
 
         if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
+                    IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
 
         if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
+                    IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
 
         if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
                 rates->supported_rates[rates->num_rates++] = basic_mask |
-                        IEEE80211_CCK_RATE_5MB;
+                    IEEE80211_CCK_RATE_5MB;
 
         if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
                 rates->supported_rates[rates->num_rates++] = basic_mask |
-                        IEEE80211_CCK_RATE_11MB;
+                    IEEE80211_CCK_RATE_11MB;
 }
 
 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
-                                u8 modulation, u32 rate_mask)
+                                    u8 modulation, u32 rate_mask)
 {
         u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
-                IEEE80211_BASIC_RATE_MASK : 0;
+            IEEE80211_BASIC_RATE_MASK : 0;
 
         if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
                 rates->supported_rates[rates->num_rates++] = basic_mask |
-                        IEEE80211_OFDM_RATE_6MB;
+                    IEEE80211_OFDM_RATE_6MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_OFDM_RATE_9MB;
+                    IEEE80211_OFDM_RATE_9MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
                 rates->supported_rates[rates->num_rates++] = basic_mask |
-                        IEEE80211_OFDM_RATE_12MB;
+                    IEEE80211_OFDM_RATE_12MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_OFDM_RATE_18MB;
+                    IEEE80211_OFDM_RATE_18MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
                 rates->supported_rates[rates->num_rates++] = basic_mask |
-                        IEEE80211_OFDM_RATE_24MB;
+                    IEEE80211_OFDM_RATE_24MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_OFDM_RATE_36MB;
+                    IEEE80211_OFDM_RATE_36MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_OFDM_RATE_48MB;
+                    IEEE80211_OFDM_RATE_48MB;
 
         if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
                 rates->supported_rates[rates->num_rates++] =
-                        IEEE80211_OFDM_RATE_54MB;
+                    IEEE80211_OFDM_RATE_54MB;
 }
 
 struct ipw_network_match {
@@ -4179,11 +4237,9 @@ struct ipw_network_match {
         struct ipw_supported_rates rates;
 };
 
-static int ipw_best_network(
-        struct ipw_priv *priv,
-        struct ipw_network_match *match,
-        struct ieee80211_network *network,
-        int roaming)
+static int ipw_best_network(struct ipw_priv *priv,
+                            struct ipw_network_match *match,
+                            struct ieee80211_network *network, int roaming)
 {
         struct ipw_supported_rates rates;
 
@@ -4231,21 +4287,21 @@ static int ipw_best_network(
                      memcmp(network->ssid, priv->essid,
                             min(network->ssid_len, priv->essid_len)))) {
                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
-                        strncpy(escaped, escape_essid(
-                                        network->ssid, network->ssid_len),
+                        strncpy(escaped,
+                                escape_essid(network->ssid, network->ssid_len),
                                 sizeof(escaped));
                         IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
                                         "because of ESSID mismatch: '%s'.\n",
                                         escaped, MAC_ARG(network->bssid),
-                                        escape_essid(priv->essid, priv->essid_len));
+                                        escape_essid(priv->essid,
+                                                     priv->essid_len));
                         return 0;
                 }
         }
 
         /* If the old network rate is better than this one, don't bother
          * testing everything else. */
-        if (match->network && match->network->stats.rssi >
-            network->stats.rssi) {
+        if (match->network && match->network->stats.rssi > network->stats.rssi) {
                 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
                 strncpy(escaped,
                         escape_essid(network->ssid, network->ssid_len),
@@ -4303,7 +4359,7 @@ static int ipw_best_network(
                                 priv->capability & CAP_PRIVACY_ON ? "on" :
                                 "off",
                                 network->capability &
-                                WLAN_CAPABILITY_PRIVACY ?"on" : "off");
+                                WLAN_CAPABILITY_PRIVACY ? "on" : "off");
                 return 0;
         }
 
@@ -4312,8 +4368,7 @@ static int ipw_best_network(
                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
                                 "because of BSSID mismatch: " MAC_FMT ".\n",
                                 escape_essid(network->ssid, network->ssid_len),
-                                MAC_ARG(network->bssid),
-                                MAC_ARG(priv->bssid));
+                                MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
                 return 0;
         }
 
@@ -4351,9 +4406,8 @@ static int ipw_best_network(
         return 1;
 }
 
-
 static void ipw_adhoc_create(struct ipw_priv *priv,
-                            struct ieee80211_network *network)
+                             struct ieee80211_network *network)
 {
         /*
          * For the purposes of scanning, we can set our wireless mode
@@ -4393,8 +4447,7 @@ static void ipw_adhoc_create(struct ipw_priv *priv,
         if (priv->capability & CAP_PRIVACY_ON)
                 network->capability |= WLAN_CAPABILITY_PRIVACY;
         network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
-        memcpy(network->rates, priv->rates.supported_rates,
-               network->rates_len);
+        memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
         network->rates_ex_len = priv->rates.num_rates - network->rates_len;
         memcpy(network->rates_ex,
                &priv->rates.supported_rates[network->rates_len],
@@ -4404,13 +4457,13 @@ static void ipw_adhoc_create(struct ipw_priv *priv,
         network->last_associate = 0;
         network->time_stamp[0] = 0;
         network->time_stamp[1] = 0;
-        network->beacon_interval = 100; /* Default */
-        network->listen_interval = 10;  /* Default */
-        network->atim_window = 0;       /* Default */
+        network->beacon_interval = 100; /* Default */
+        network->listen_interval = 10;  /* Default */
+        network->atim_window = 0;       /* Default */
 #ifdef CONFIG_IEEE80211_WPA
         network->wpa_ie_len = 0;
         network->rsn_ie_len = 0;
-#endif /* CONFIG_IEEE80211_WPA */
+#endif                          /* CONFIG_IEEE80211_WPA */
 }
 
 static void ipw_send_wep_keys(struct ipw_priv *priv)
@@ -4464,14 +4517,12 @@ static void ipw_debug_config(struct ipw_priv *priv)
         IPW_DEBUG_INFO("Scan completed, no valid APs matched "
                        "[CFG 0x%08X]\n", priv->config);
         if (priv->config & CFG_STATIC_CHANNEL)
-                IPW_DEBUG_INFO("Channel locked to %d\n",
-                               priv->channel);
+                IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
         else
                 IPW_DEBUG_INFO("Channel unlocked.\n");
         if (priv->config & CFG_STATIC_ESSID)
                 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
-                               escape_essid(priv->essid,
-                                            priv->essid_len));
+                               escape_essid(priv->essid, priv->essid_len));
         else
                 IPW_DEBUG_INFO("ESSID unlocked.\n");
         if (priv->config & CFG_STATIC_BSSID)
@@ -4502,7 +4553,7 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
          * Tx rates */
 
         switch (priv->ieee->freq_band) {
-        case IEEE80211_52GHZ_BAND: /* A only */
+        case IEEE80211_52GHZ_BAND:      /* A only */
                 /* IEEE_A */
                 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
                         /* Invalid fixed rate mask */
@@ -4513,7 +4564,7 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
                 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
                 break;
 
-        default: /* 2.4Ghz or Mixed */
+        default:                /* 2.4Ghz or Mixed */
                 /* IEEE_B */
                 if (network->mode == IEEE_B) {
                         if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
@@ -4551,13 +4602,12 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
         }
 
         reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
-        ipw_write_reg32(priv, reg, *(u32*)&fr);
+        ipw_write_reg32(priv, reg, *(u32 *) & fr);
 }
 
 static int ipw_associate_network(struct ipw_priv *priv,
                                  struct ieee80211_network *network,
-                                 struct ipw_supported_rates *rates,
-                                 int roaming)
+                                 struct ipw_supported_rates *rates, int roaming)
 {
         int err;
 
@@ -4566,7 +4616,7 @@ static int ipw_associate_network(struct ipw_priv *priv,
 
         if (!(priv->config & CFG_STATIC_ESSID)) {
                 priv->essid_len = min(network->ssid_len,
-                                      (u8)IW_ESSID_MAX_SIZE);
+                                      (u8) IW_ESSID_MAX_SIZE);
                 memcpy(priv->essid, network->ssid, priv->essid_len);
         }
 
@@ -4612,13 +4662,11 @@ static int ipw_associate_network(struct ipw_priv *priv,
                         priv->capability & CAP_PRIVACY_ON ? " key=" : "",
                         priv->capability & CAP_PRIVACY_ON ?
                         '1' + priv->sec.active_key : '.',
-                        priv->capability & CAP_PRIVACY_ON ?
-                        '.' : ' ');
+                        priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
 
         priv->assoc_request.beacon_interval = network->beacon_interval;
         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
-            (network->time_stamp[0] == 0) &&
-            (network->time_stamp[1] == 0)) {
+            (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
                 priv->assoc_request.assoc_type = HC_IBSS_START;
                 priv->assoc_request.assoc_tsf_msw = 0;
                 priv->assoc_request.assoc_tsf_lsw = 0;
@@ -4637,8 +4685,7 @@ static int ipw_associate_network(struct ipw_priv *priv,
                 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
                 priv->assoc_request.atim_window = network->atim_window;
         } else {
-                memcpy(&priv->assoc_request.dest, network->bssid,
-                       ETH_ALEN);
+                memcpy(&priv->assoc_request.dest, network->bssid, ETH_ALEN);
                 priv->assoc_request.atim_window = 0;
         }
 
@@ -4772,14 +4819,13 @@ static void ipw_associate(void *data)
 
         if (!(priv->config & CFG_ASSOCIATE) &&
             !(priv->config & (CFG_STATIC_ESSID |
-                              CFG_STATIC_CHANNEL |
-                              CFG_STATIC_BSSID))) {
+                              CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
                 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
                 return;
         }
 
         list_for_each_entry(network, &priv->ieee->network_list, list)
-                ipw_best_network(priv, &match, network, 0);
+            ipw_best_network(priv, &match, network, 0);
 
         network = match.network;
         rates = &match.rates;
@@ -4790,8 +4836,7 @@ static void ipw_associate(void *data)
             priv->config & CFG_STATIC_ESSID &&
             !list_empty(&priv->ieee->network_free_list)) {
                 element = priv->ieee->network_free_list.next;
-                network = list_entry(element, struct ieee80211_network,
-                                     list);
+                network = list_entry(element, struct ieee80211_network, list);
                 ipw_adhoc_create(priv, network);
                 rates = &priv->rates;
                 list_del(element);
@@ -4813,8 +4858,8 @@ static void ipw_associate(void *data)
 }
 
 static inline void ipw_handle_data_packet(struct ipw_priv *priv,
-                                              struct ipw_rx_mem_buffer *rxb,
-                                              struct ieee80211_rx_stats *stats)
+                                          struct ipw_rx_mem_buffer *rxb,
+                                          struct ieee80211_rx_stats *stats)
 {
         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
 
@@ -4846,11 +4891,10 @@ static inline void ipw_handle_data_packet(struct ipw_priv *priv,
 
         if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
                 priv->ieee->stats.rx_errors++;
-        else /* ieee80211_rx succeeded, so it now owns the SKB */
+        else                    /* ieee80211_rx succeeded, so it now owns the SKB */
                 rxb->skb = NULL;
 }
 
-
 /*
  * Main entry function for recieving a packet with 80211 headers.  This
  * should be called when ever the FW has notified us that there is a new
@@ -4885,125 +4929,152 @@ static void ipw_rx(struct ipw_priv *priv)
                 pkt = (struct ipw_rx_packet *)rxb->skb->data;
                 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
                              pkt->header.message_type,
-                             pkt->header.rx_seq_num,
-                             pkt->header.control_bits);
+                             pkt->header.rx_seq_num, pkt->header.control_bits);
 
                 switch (pkt->header.message_type) {
-                case RX_FRAME_TYPE: /* 802.11 frame */ {
-                        struct ieee80211_rx_stats stats = {
-                                .rssi = pkt->u.frame.rssi_dbm -
-                                IPW_RSSI_TO_DBM,
-                                .signal = pkt->u.frame.signal,
-                                .rate = pkt->u.frame.rate,
-                                .mac_time = jiffies,
-                                .received_channel =
-                                pkt->u.frame.received_channel,
-                                .freq = (pkt->u.frame.control & (1<<0)) ?
-                                IEEE80211_24GHZ_BAND : IEEE80211_52GHZ_BAND,
-                                .len = pkt->u.frame.length,
-                        };
-
-                        if (stats.rssi != 0)
-                                stats.mask |= IEEE80211_STATMASK_RSSI;
-                        if (stats.signal != 0)
-                                stats.mask |= IEEE80211_STATMASK_SIGNAL;
-                        if (stats.rate != 0)
-                                stats.mask |= IEEE80211_STATMASK_RATE;
-
-                        priv->rx_packets++;
+                case RX_FRAME_TYPE:     /* 802.11 frame */  {
+                                struct ieee80211_rx_stats stats = {
+                                        .rssi = pkt->u.frame.rssi_dbm -
+                                            IPW_RSSI_TO_DBM,
+                                        .signal = pkt->u.frame.signal,
+                                        .rate = pkt->u.frame.rate,
+                                        .mac_time = jiffies,
+                                        .received_channel =
+                                            pkt->u.frame.received_channel,
+                                        .freq =
+                                            (pkt->u.frame.
+                                             control & (1 << 0)) ?
+                                            IEEE80211_24GHZ_BAND :
+                                            IEEE80211_52GHZ_BAND,
+                                        .len = pkt->u.frame.length,
+                                };
+
+                                if (stats.rssi != 0)
+                                        stats.mask |= IEEE80211_STATMASK_RSSI;
+                                if (stats.signal != 0)
+                                        stats.mask |= IEEE80211_STATMASK_SIGNAL;
+                                if (stats.rate != 0)
+                                        stats.mask |= IEEE80211_STATMASK_RATE;
+
+                                priv->rx_packets++;
 
 #ifdef CONFIG_IPW_PROMISC
-                        if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
-                                ipw_handle_data_packet(priv, rxb, &stats);
-                                break;
-                        }
+                                if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
+                                        ipw_handle_data_packet(priv, rxb,
+                                                               &stats);
+                                        break;
+                                }
 #endif
 
-                        header = (struct ieee80211_hdr *)(rxb->skb->data +
-                                                          IPW_RX_FRAME_SIZE);
+                                header =
+                                    (struct ieee80211_hdr *)(rxb->skb->data +
+                                                             IPW_RX_FRAME_SIZE);
                                 /* TODO: Check Ad-Hoc dest/source and make sure
                                  * that we are actually parsing these packets
                                  * correctly -- we should probably use the
                                  * frame control of the packet and disregard
                                  * the current iw_mode */
-                        switch (priv->ieee->iw_mode) {
-                        case IW_MODE_ADHOC:
-                                network_packet =
-                                        !memcmp(header->addr1,
-                                                priv->net_dev->dev_addr,
-                                                ETH_ALEN) ||
-                                        !memcmp(header->addr3,
-                                                priv->bssid, ETH_ALEN) ||
-                                        is_broadcast_ether_addr(header->addr1) ||
-                                        is_multicast_ether_addr(header->addr1);
-                                break;
-
-                        case IW_MODE_INFRA:
-                        default:
-                                network_packet =
-                                        !memcmp(header->addr3,
-                                                priv->bssid, ETH_ALEN) ||
-                                        !memcmp(header->addr1,
-                                                priv->net_dev->dev_addr,
-                                                ETH_ALEN) ||
-                                        is_broadcast_ether_addr(header->addr1) ||
-                                        is_multicast_ether_addr(header->addr1);
+                                switch (priv->ieee->iw_mode) {
+                                case IW_MODE_ADHOC:
+                                        network_packet =
+                                            !memcmp(header->addr1,
+                                                    priv->net_dev->dev_addr,
+                                                    ETH_ALEN) ||
+                                            !memcmp(header->addr3,
+                                                    priv->bssid, ETH_ALEN) ||
+                                            is_broadcast_ether_addr(header->
+                                                                    addr1)
+                                            || is_multicast_ether_addr(header->
+                                                                       addr1);
+                                        break;
+
+                                case IW_MODE_INFRA:
+                                default:
+                                        network_packet =
+                                            !memcmp(header->addr3,
+                                                    priv->bssid, ETH_ALEN) ||
+                                            !memcmp(header->addr1,
+                                                    priv->net_dev->dev_addr,
+                                                    ETH_ALEN) ||
+                                            is_broadcast_ether_addr(header->
+                                                                    addr1)
+                                            || is_multicast_ether_addr(header->
+                                                                       addr1);
+                                        break;
+                                }
+
+                                if (network_packet && priv->assoc_network) {
+                                        priv->assoc_network->stats.rssi =
+                                            stats.rssi;
+                                        average_add(&priv->average_rssi,
+                                                    stats.rssi);
+                                        priv->last_rx_rssi = stats.rssi;
+                                }
+
+                                IPW_DEBUG_RX("Frame: len=%u\n",
+                                             pkt->u.frame.length);
+
+                                if (pkt->u.frame.length < frame_hdr_len(header)) {
+                                        IPW_DEBUG_DROP
+                                            ("Received packet is too small. "
+                                             "Dropping.\n");
+                                        priv->ieee->stats.rx_errors++;
+                                        priv->wstats.discard.misc++;
+                                        break;
+                                }
+
+                                switch (WLAN_FC_GET_TYPE(header->frame_ctl)) {
+                                case IEEE80211_FTYPE_MGMT:
+                                        ieee80211_rx_mgt(priv->ieee, header,
+                                                         &stats);
+                                        if (priv->ieee->iw_mode == IW_MODE_ADHOC
+                                            &&
+                                            ((WLAN_FC_GET_STYPE
+                                              (header->frame_ctl) ==
+                                              IEEE80211_STYPE_PROBE_RESP)
+                                             ||
+                                             (WLAN_FC_GET_STYPE
+                                              (header->frame_ctl) ==
+                                              IEEE80211_STYPE_BEACON))
+                                            && !memcmp(header->addr3,
+                                                       priv->bssid, ETH_ALEN))
+                                                ipw_add_station(priv,
+                                                                header->addr2);
+                                        break;
+
+                                case IEEE80211_FTYPE_CTL:
+                                        break;
+
+                                case IEEE80211_FTYPE_DATA:
+                                        if (network_packet)
+                                                ipw_handle_data_packet(priv,
+                                                                       rxb,
+                                                                       &stats);
+                                        else
+                                                IPW_DEBUG_DROP("Dropping: "
+                                                               MAC_FMT ", "
+                                                               MAC_FMT ", "
+                                                               MAC_FMT "\n",
+                                                               MAC_ARG(header->
+                                                                       addr1),
+                                                               MAC_ARG(header->
+                                                                       addr2),
+                                                               MAC_ARG(header->
+                                                                       addr3));
+                                        break;
+                                }
                                 break;
                         }
 
-                        if (network_packet && priv->assoc_network) {
-                                priv->assoc_network->stats.rssi = stats.rssi;
-                                average_add(&priv->average_rssi,
-                                            stats.rssi);
-                                priv->last_rx_rssi = stats.rssi;
-                        }
-
-                        IPW_DEBUG_RX("Frame: len=%u\n", pkt->u.frame.length);
-
-                        if (pkt->u.frame.length < frame_hdr_len(header)) {
-                                IPW_DEBUG_DROP("Received packet is too small. "
-                                               "Dropping.\n");
-                                priv->ieee->stats.rx_errors++;
-                                priv->wstats.discard.misc++;
-                                break;
-                        }
-
-                        switch (WLAN_FC_GET_TYPE(header->frame_ctl)) {
-                        case IEEE80211_FTYPE_MGMT:
-                                ieee80211_rx_mgt(priv->ieee, header, &stats);
-                                if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
-                                    ((WLAN_FC_GET_STYPE(header->frame_ctl) ==
-                                      IEEE80211_STYPE_PROBE_RESP) ||
-                                     (WLAN_FC_GET_STYPE(header->frame_ctl) ==
-                                      IEEE80211_STYPE_BEACON)) &&
-                                    !memcmp(header->addr3, priv->bssid, ETH_ALEN))
-                                        ipw_add_station(priv, header->addr2);
-                                break;
-
-                        case IEEE80211_FTYPE_CTL:
-                                break;
-
-                        case IEEE80211_FTYPE_DATA:
-                                if (network_packet)
-                                        ipw_handle_data_packet(priv, rxb, &stats);
-                                else
-                                        IPW_DEBUG_DROP("Dropping: " MAC_FMT
-                                                       ", " MAC_FMT ", " MAC_FMT "\n",
-                                                       MAC_ARG(header->addr1), MAC_ARG(header->addr2),
-                                                       MAC_ARG(header->addr3));
-                                break;
-                        }
-                        break;
-                }
-
-                case RX_HOST_NOTIFICATION_TYPE: {
-                        IPW_DEBUG_RX("Notification: subtype=%02X flags=%02X size=%d\n",
+                case RX_HOST_NOTIFICATION_TYPE:{
+                                IPW_DEBUG_RX
+                                    ("Notification: subtype=%02X flags=%02X size=%d\n",
                                      pkt->u.notification.subtype,
                                      pkt->u.notification.flags,
                                      pkt->u.notification.size);
-                        ipw_rx_notification(priv, &pkt->u.notification);
-                        break;
-                }
+                                ipw_rx_notification(priv, &pkt->u.notification);
+                                break;
+                        }
 
                 default:
                         IPW_DEBUG_RX("Bad Rx packet of type %d\n",
@@ -5088,10 +5159,10 @@ static int ipw_request_scan(struct ipw_priv *priv)
         /* If we are roaming, then make this a directed scan for the current
          * network.  Otherwise, ensure that every other scan is a fast
          * channel hop scan */
-        if ((priv->status & STATUS_ROAMING) || (
-                    !(priv->status & STATUS_ASSOCIATED) &&
-                    (priv->config & CFG_STATIC_ESSID) &&
-                    (scan.full_scan_index % 2))) {
+        if ((priv->status & STATUS_ROAMING)
+            || (!(priv->status & STATUS_ASSOCIATED)
+                && (priv->config & CFG_STATIC_ESSID)
+                && (scan.full_scan_index % 2))) {
                 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
                 if (err) {
                         IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
@@ -5103,7 +5174,7 @@ static int ipw_request_scan(struct ipw_priv *priv)
                 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
         }
 
-        if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
+        if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
                 int start = channel_index;
                 for (i = 0; i < MAX_A_CHANNELS; i++) {
                         if (band_a_active_channel[i] == 0)
@@ -5113,18 +5184,18 @@ static int ipw_request_scan(struct ipw_priv *priv)
                                 continue;
                         channel_index++;
                         scan.channels_list[channel_index] =
-                                band_a_active_channel[i];
+                            band_a_active_channel[i];
                         ipw_set_scan_type(&scan, channel_index, scan_type);
                 }
 
                 if (start != channel_index) {
-                        scan.channels_list[start] = (u8)(IPW_A_MODE << 6) |
-                                (channel_index - start);
+                        scan.channels_list[start] = (u8) (IPW_A_MODE << 6) |
+                            (channel_index - start);
                         channel_index++;
                 }
         }
 
-        if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
+        if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
                 int start = channel_index;
                 for (i = 0; i < MAX_B_CHANNELS; i++) {
                         if (band_b_active_channel[i] == 0)
@@ -5134,20 +5205,19 @@ static int ipw_request_scan(struct ipw_priv *priv)
                                 continue;
                         channel_index++;
                         scan.channels_list[channel_index] =
-                                band_b_active_channel[i];
+                            band_b_active_channel[i];
                         ipw_set_scan_type(&scan, channel_index, scan_type);
                 }
 
                 if (start != channel_index) {
-                        scan.channels_list[start] = (u8)(IPW_B_MODE << 6) |
-                                (channel_index - start);
+                        scan.channels_list[start] = (u8) (IPW_B_MODE << 6) |
+                            (channel_index - start);
                 }
         }
 
         err = ipw_send_scan_request_ext(priv, &scan);
         if (err) {
-                IPW_DEBUG_HC("Sending scan command failed: %08X\n",
-                             err);
+                IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
                 return -EIO;
         }
 
@@ -5199,9 +5269,8 @@ static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
         priv->config |= CFG_STATIC_CHANNEL;
 
         if (priv->channel == channel) {
-                IPW_DEBUG_INFO(
-                        "Request to set channel to current value (%d)\n",
-                        channel);
+                IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
+                               channel);
                 return 0;
         }
 
@@ -5229,8 +5298,7 @@ static int ipw_wx_set_freq(struct net_device *dev,
 
         /* if setting by freq convert to channel */
         if (fwrq->e == 1) {
-                if ((fwrq->m >= (int) 2.412e8 &&
-                     fwrq->m <= (int) 2.487e8)) {
+                if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) {
                         int f = fwrq->m / 100000;
                         int c = 0;
 
@@ -5248,12 +5316,11 @@ static int ipw_wx_set_freq(struct net_device *dev,
                 return -EOPNOTSUPP;
 
         IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
-        return ipw_set_channel(priv, (u8)fwrq->m);
+        return ipw_set_channel(priv, (u8) fwrq->m);
 
         return 0;
 }
 
-
 static int ipw_wx_get_freq(struct net_device *dev,
                            struct iw_request_info *info,
                            union iwreq_data *wrqu, char *extra)
@@ -5306,7 +5373,7 @@ static int ipw_wx_set_mode(struct net_device *dev,
 
         if (wrqu->mode == IW_MODE_MONITOR)
                 priv->net_dev->type = ARPHRD_IEEE80211;
-#endif /* CONFIG_IPW_PROMISC */
+#endif                          /* CONFIG_IPW_PROMISC */
 
 #ifdef CONFIG_PM
         /* Free the existing firmware and reset the fw_loaded
@@ -5324,12 +5391,12 @@ static int ipw_wx_set_mode(struct net_device *dev,
         priv->ieee->iw_mode = wrqu->mode;
         ipw_adapter_restart(priv);
 
-        return err;
+        return err;
 }
 
 static int ipw_wx_get_mode(struct net_device *dev,
-                               struct iw_request_info *info,
-                               union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
 
@@ -5339,7 +5406,6 @@ static int ipw_wx_get_mode(struct net_device *dev,
         return 0;
 }
 
-
 #define DEFAULT_RTS_THRESHOLD     2304U
 #define MIN_RTS_THRESHOLD         1U
 #define MAX_RTS_THRESHOLD         2304U
@@ -5383,19 +5449,19 @@ static int ipw_wx_get_range(struct net_device *dev,
         /* TODO: Find real max RSSI and stick here */
         range->max_qual.level = 0;
         range->max_qual.noise = 0;
-        range->max_qual.updated = 7; /* Updated all three */
+        range->max_qual.updated = 7;    /* Updated all three */
 
         range->avg_qual.qual = 70;
         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
-        range->avg_qual.level = 0; /* FIXME to real average level */
+        range->avg_qual.level = 0;      /* FIXME to real average level */
         range->avg_qual.noise = 0;
-        range->avg_qual.updated = 7; /* Updated all three */
+        range->avg_qual.updated = 7;    /* Updated all three */
 
-        range->num_bitrates = min(priv->rates.num_rates, (u8)IW_MAX_BITRATES);
+        range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
 
         for (i = 0; i < range->num_bitrates; i++)
                 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
-                        500000;
+                    500000;
 
         range->max_rts = DEFAULT_RTS_THRESHOLD;
         range->min_frag = MIN_FRAG_THRESHOLD;
@@ -5410,7 +5476,7 @@ static int ipw_wx_get_range(struct net_device *dev,
         range->we_version_compiled = WIRELESS_EXT;
         range->we_version_source = 16;
 
-        range->num_channels = FREQ_COUNT;
+        range->num_channels = FREQ_COUNT;
 
         val = 0;
         for (i = 0; i < FREQ_COUNT; i++) {
@@ -5506,7 +5572,7 @@ static int ipw_wx_set_essid(struct net_device *dev,
                             union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
-        char *essid = ""; /* ANY */
+        char *essid = "";       /* ANY */
         int length = 0;
 
         if (wrqu->essid.flags && wrqu->essid.length) {
@@ -5567,11 +5633,11 @@ static int ipw_wx_get_essid(struct net_device *dev,
                              escape_essid(priv->essid, priv->essid_len));
                 memcpy(extra, priv->essid, priv->essid_len);
                 wrqu->essid.length = priv->essid_len;
-                wrqu->essid.flags = 1; /* active */
+                wrqu->essid.flags = 1;  /* active */
         } else {
                 IPW_DEBUG_WX("Getting essid: ANY\n");
                 wrqu->essid.length = 0;
-                wrqu->essid.flags = 0; /* active */
+                wrqu->essid.flags = 0;  /* active */
         }
 
         return 0;
@@ -5587,15 +5653,14 @@ static int ipw_wx_set_nick(struct net_device *dev,
         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
                 return -E2BIG;
 
-        wrqu->data.length = min((size_t)wrqu->data.length, sizeof(priv->nick));
+        wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
         memset(priv->nick, 0, sizeof(priv->nick));
-        memcpy(priv->nick, extra,  wrqu->data.length);
+        memcpy(priv->nick, extra, wrqu->data.length);
         IPW_DEBUG_TRACE("<<\n");
         return 0;
 
 }
 
-
 static int ipw_wx_get_nick(struct net_device *dev,
                            struct iw_request_info *info,
                            union iwreq_data *wrqu, char *extra)
@@ -5604,11 +5669,10 @@ static int ipw_wx_get_nick(struct net_device *dev,
         IPW_DEBUG_WX("Getting nick\n");
         wrqu->data.length = strlen(priv->nick) + 1;
         memcpy(extra, priv->nick, wrqu->data.length);
-        wrqu->data.flags = 1; /* active */
+        wrqu->data.flags = 1;   /* active */
         return 0;
 }
 
-
 static int ipw_wx_set_rate(struct net_device *dev,
                            struct iw_request_info *info,
                            union iwreq_data *wrqu, char *extra)
@@ -5621,14 +5685,13 @@ static int ipw_wx_get_rate(struct net_device *dev,
                            struct iw_request_info *info,
                            union iwreq_data *wrqu, char *extra)
 {
-        struct ipw_priv * priv = ieee80211_priv(dev);
+        struct ipw_priv *priv = ieee80211_priv(dev);
         wrqu->bitrate.value = priv->last_rate;
 
         IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
         return 0;
 }
 
-
 static int ipw_wx_set_rts(struct net_device *dev,
                           struct iw_request_info *info,
                           union iwreq_data *wrqu, char *extra)
@@ -5657,14 +5720,12 @@ static int ipw_wx_get_rts(struct net_device *dev,
         struct ipw_priv *priv = ieee80211_priv(dev);
         wrqu->rts.value = priv->rts_threshold;
         wrqu->rts.fixed = 0;    /* no auto select */
-        wrqu->rts.disabled =
-                (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
+        wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
 
         IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
         return 0;
 }
 
-
 static int ipw_wx_set_txpow(struct net_device *dev,
                             struct iw_request_info *info,
                             union iwreq_data *wrqu, char *extra)
@@ -5679,8 +5740,7 @@ static int ipw_wx_set_txpow(struct net_device *dev,
         if (wrqu->power.flags != IW_TXPOW_DBM)
                 return -EINVAL;
 
-        if ((wrqu->power.value > 20) ||
-            (wrqu->power.value < -12))
+        if ((wrqu->power.value > 20) || (wrqu->power.value < -12))
                 return -EINVAL;
 
         priv->tx_power = wrqu->power.value;
@@ -5704,11 +5764,10 @@ static int ipw_wx_set_txpow(struct net_device *dev,
 
         return 0;
 
- error:
+      error:
         return -EIO;
 }
 
-
 static int ipw_wx_get_txpow(struct net_device *dev,
                             struct iw_request_info *info,
                             union iwreq_data *wrqu, char *extra)
@@ -5721,15 +5780,14 @@ static int ipw_wx_get_txpow(struct net_device *dev,
         wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
 
         IPW_DEBUG_WX("GET TX Power -> %s %d \n",
-                     wrqu->power.disabled ? "ON" : "OFF",
-                     wrqu->power.value);
+                     wrqu->power.disabled ? "ON" : "OFF", wrqu->power.value);
 
         return 0;
 }
 
 static int ipw_wx_set_frag(struct net_device *dev,
-                               struct iw_request_info *info,
-                               union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
 
@@ -5749,14 +5807,13 @@ static int ipw_wx_set_frag(struct net_device *dev,
 }
 
 static int ipw_wx_get_frag(struct net_device *dev,
-                               struct iw_request_info *info,
-                               union iwreq_data *wrqu, char *extra)
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         wrqu->frag.value = priv->ieee->fts;
         wrqu->frag.fixed = 0;   /* no auto select */
-        wrqu->frag.disabled =
-                (wrqu->frag.value == DEFAULT_FTS);
+        wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
 
         IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
 
@@ -5771,7 +5828,6 @@ static int ipw_wx_set_retry(struct net_device *dev,
         return -EOPNOTSUPP;
 }
 
-
 static int ipw_wx_get_retry(struct net_device *dev,
                             struct iw_request_info *info,
                             union iwreq_data *wrqu, char *extra)
@@ -5780,7 +5836,6 @@ static int ipw_wx_get_retry(struct net_device *dev,
         return -EOPNOTSUPP;
 }
 
-
 static int ipw_wx_set_scan(struct net_device *dev,
                            struct iw_request_info *info,
                            union iwreq_data *wrqu, char *extra)
@@ -5801,24 +5856,24 @@ static int ipw_wx_get_scan(struct net_device *dev,
 }
 
 static int ipw_wx_set_encode(struct net_device *dev,
-                                 struct iw_request_info *info,
-                                 union iwreq_data *wrqu, char *key)
+                             struct iw_request_info *info,
+                             union iwreq_data *wrqu, char *key)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         return ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
 }
 
 static int ipw_wx_get_encode(struct net_device *dev,
-                                 struct iw_request_info *info,
-                                 union iwreq_data *wrqu, char *key)
+                             struct iw_request_info *info,
+                             union iwreq_data *wrqu, char *key)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
 }
 
 static int ipw_wx_set_power(struct net_device *dev,
-                                struct iw_request_info *info,
-                                union iwreq_data *wrqu, char *extra)
+                            struct iw_request_info *info,
+                            union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         int err;
@@ -5837,11 +5892,11 @@ static int ipw_wx_set_power(struct net_device *dev,
         }
 
         switch (wrqu->power.flags & IW_POWER_MODE) {
-        case IW_POWER_ON:    /* If not specified */
-        case IW_POWER_MODE:  /* If set all mask */
-        case IW_POWER_ALL_R: /* If explicitely state all */
+        case IW_POWER_ON:       /* If not specified */
+        case IW_POWER_MODE:     /* If set all mask */
+        case IW_POWER_ALL_R:    /* If explicitely state all */
                 break;
-        default: /* Otherwise we don't support it */
+        default:                /* Otherwise we don't support it */
                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
                              wrqu->power.flags);
                 return -EOPNOTSUPP;
@@ -5849,7 +5904,7 @@ static int ipw_wx_set_power(struct net_device *dev,
 
         /* If the user hasn't specified a power management mode yet, default
          * to BATTERY */
-        if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
+        if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
                 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
         else
                 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
@@ -5859,15 +5914,14 @@ static int ipw_wx_set_power(struct net_device *dev,
                 return err;
         }
 
-        IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n",
-                     priv->power_mode);
+        IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
 
         return 0;
 }
 
 static int ipw_wx_get_power(struct net_device *dev,
-                                struct iw_request_info *info,
-                                union iwreq_data *wrqu, char *extra)
+                            struct iw_request_info *info,
+                            union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
 
@@ -5883,8 +5937,8 @@ static int ipw_wx_get_power(struct net_device *dev,
 }
 
 static int ipw_wx_set_powermode(struct net_device *dev,
-                                    struct iw_request_info *info,
-                                    union iwreq_data *wrqu, char *extra)
+                                struct iw_request_info *info,
+                                union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         int mode = *(int *)extra;
@@ -5911,8 +5965,8 @@ static int ipw_wx_set_powermode(struct net_device *dev,
 
 #define MAX_WX_STRING 80
 static int ipw_wx_get_powermode(struct net_device *dev,
-                                    struct iw_request_info *info,
-                                    union iwreq_data *wrqu, char *extra)
+                                struct iw_request_info *info,
+                                union iwreq_data *wrqu, char *extra)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         int level = IPW_POWER_LEVEL(priv->power_mode);
@@ -5935,7 +5989,7 @@ static int ipw_wx_get_powermode(struct net_device *dev,
         }
 
         if (!(priv->power_mode & IPW_POWER_ENABLED))
-                p += snprintf(p, MAX_WX_STRING - (p - extra)," OFF");
+                p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
 
         wrqu->data.length = p - extra + 1;
 
@@ -5943,16 +5997,15 @@ static int ipw_wx_get_powermode(struct net_device *dev,
 }
 
 static int ipw_wx_set_wireless_mode(struct net_device *dev,
-                                    struct iw_request_info *info,
-                                    union iwreq_data *wrqu, char *extra)
+                                    struct iw_request_info *info,
+                                    union iwreq_data *wrqu, char *extra)
 {
-        struct ipw_priv *priv = ieee80211_priv(dev);
+        struct ipw_priv *priv = ieee80211_priv(dev);
         int mode = *(int *)extra;
         u8 band = 0, modulation = 0;
 
         if (mode == 0 || mode & ~IEEE_MODE_MASK) {
-                IPW_WARNING("Attempt to set invalid wireless mode: %d\n",
-                            mode);
+                IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
                 return -EINVAL;
         }
 
@@ -5988,31 +6041,30 @@ static int ipw_wx_set_wireless_mode(struct net_device *dev,
         priv->ieee->mode = mode;
         priv->ieee->freq_band = band;
         priv->ieee->modulation = modulation;
-        init_supported_rates(priv, &priv->rates);
+        init_supported_rates(priv, &priv->rates);
 
         /* If we are currently associated, or trying to associate
-         * then see if this is a new configuration (causing us to
+         * then see if this is a new configuration (causing us to
          * disassociate) */
-        if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
+        if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
                 /* The resulting association will trigger
                  * the new rates to be sent to the device */
-                IPW_DEBUG_ASSOC("Disassociating due to mode change.\n");
-                ipw_disassociate(priv);
+                IPW_DEBUG_ASSOC("Disassociating due to mode change.\n");
+                ipw_disassociate(priv);
         } else
                 ipw_send_supported_rates(priv, &priv->rates);
 
         IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
                      mode & IEEE_A ? 'a' : '.',
-                     mode & IEEE_B ? 'b' : '.',
-                     mode & IEEE_G ? 'g' : '.');
+                     mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
         return 0;
 }
 
 static int ipw_wx_get_wireless_mode(struct net_device *dev,
-                                    struct iw_request_info *info,
-                                    union iwreq_data *wrqu, char *extra)
+                                    struct iw_request_info *info,
+                                    union iwreq_data *wrqu, char *extra)
 {
-        struct ipw_priv *priv = ieee80211_priv(dev);
+        struct ipw_priv *priv = ieee80211_priv(dev);
 
         switch (priv->ieee->freq_band) {
         case IEEE80211_24GHZ_BAND:
@@ -6033,7 +6085,7 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev,
                 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
                 break;
 
-        default: /* Mixed Band */
+        default:                /* Mixed Band */
                 switch (priv->ieee->modulation) {
                 case IEEE80211_CCK_MODULATION:
                         strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
@@ -6050,9 +6102,9 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev,
 
         IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
 
-        wrqu->data.length = strlen(extra) + 1;
+        wrqu->data.length = strlen(extra) + 1;
 
-        return 0;
+        return 0;
 }
 
 #ifdef CONFIG_IPW_PROMISC
@@ -6081,7 +6133,6 @@ static int ipw_wx_set_promisc(struct net_device *dev,
         return 0;
 }
 
-
 static int ipw_wx_reset(struct net_device *dev,
                         struct iw_request_info *info,
                         union iwreq_data *wrqu, char *extra)
@@ -6091,40 +6142,39 @@ static int ipw_wx_reset(struct net_device *dev,
         ipw_adapter_restart(priv);
         return 0;
 }
-#endif // CONFIG_IPW_PROMISC
+#endif                          // CONFIG_IPW_PROMISC
 
 /* Rebase the WE IOCTLs to zero for the handler array */
 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
-static iw_handler ipw_wx_handlers[] =
-{
-        IW_IOCTL(SIOCGIWNAME)   = ipw_wx_get_name,
-        IW_IOCTL(SIOCSIWFREQ)   = ipw_wx_set_freq,
-        IW_IOCTL(SIOCGIWFREQ)   = ipw_wx_get_freq,
-        IW_IOCTL(SIOCSIWMODE)   = ipw_wx_set_mode,
-        IW_IOCTL(SIOCGIWMODE)   = ipw_wx_get_mode,
-        IW_IOCTL(SIOCGIWRANGE)  = ipw_wx_get_range,
-        IW_IOCTL(SIOCSIWAP)     = ipw_wx_set_wap,
-        IW_IOCTL(SIOCGIWAP)     = ipw_wx_get_wap,
-        IW_IOCTL(SIOCSIWSCAN)   = ipw_wx_set_scan,
-        IW_IOCTL(SIOCGIWSCAN)   = ipw_wx_get_scan,
-        IW_IOCTL(SIOCSIWESSID)  = ipw_wx_set_essid,
-        IW_IOCTL(SIOCGIWESSID)  = ipw_wx_get_essid,
-        IW_IOCTL(SIOCSIWNICKN)  = ipw_wx_set_nick,
-        IW_IOCTL(SIOCGIWNICKN)  = ipw_wx_get_nick,
-        IW_IOCTL(SIOCSIWRATE)   = ipw_wx_set_rate,
-        IW_IOCTL(SIOCGIWRATE)   = ipw_wx_get_rate,
-        IW_IOCTL(SIOCSIWRTS)    = ipw_wx_set_rts,
-        IW_IOCTL(SIOCGIWRTS)    = ipw_wx_get_rts,
-        IW_IOCTL(SIOCSIWFRAG)   = ipw_wx_set_frag,
-        IW_IOCTL(SIOCGIWFRAG)   = ipw_wx_get_frag,
-        IW_IOCTL(SIOCSIWTXPOW)  = ipw_wx_set_txpow,
-        IW_IOCTL(SIOCGIWTXPOW)  = ipw_wx_get_txpow,
-        IW_IOCTL(SIOCSIWRETRY)  = ipw_wx_set_retry,
-        IW_IOCTL(SIOCGIWRETRY)  = ipw_wx_get_retry,
-        IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
-        IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
-        IW_IOCTL(SIOCSIWPOWER)  = ipw_wx_set_power,
-        IW_IOCTL(SIOCGIWPOWER)  = ipw_wx_get_power,
+static iw_handler ipw_wx_handlers[] = {
+        IW_IOCTL(SIOCGIWNAME)   = ipw_wx_get_name,
+        IW_IOCTL(SIOCSIWFREQ)   = ipw_wx_set_freq,
+        IW_IOCTL(SIOCGIWFREQ)   = ipw_wx_get_freq,
+        IW_IOCTL(SIOCSIWMODE)   = ipw_wx_set_mode,
+        IW_IOCTL(SIOCGIWMODE)   = ipw_wx_get_mode,
+        IW_IOCTL(SIOCGIWRANGE)  = ipw_wx_get_range,
+        IW_IOCTL(SIOCSIWAP)     = ipw_wx_set_wap,
+        IW_IOCTL(SIOCGIWAP)     = ipw_wx_get_wap,
+        IW_IOCTL(SIOCSIWSCAN)   = ipw_wx_set_scan,
+        IW_IOCTL(SIOCGIWSCAN)   = ipw_wx_get_scan,
+        IW_IOCTL(SIOCSIWESSID)  = ipw_wx_set_essid,
+        IW_IOCTL(SIOCGIWESSID)  = ipw_wx_get_essid,
+        IW_IOCTL(SIOCSIWNICKN)  = ipw_wx_set_nick,
+        IW_IOCTL(SIOCGIWNICKN)  = ipw_wx_get_nick,
+        IW_IOCTL(SIOCSIWRATE)   = ipw_wx_set_rate,
+        IW_IOCTL(SIOCGIWRATE)   = ipw_wx_get_rate,
+        IW_IOCTL(SIOCSIWRTS)    = ipw_wx_set_rts,
+        IW_IOCTL(SIOCGIWRTS)    = ipw_wx_get_rts,
+        IW_IOCTL(SIOCSIWFRAG)   = ipw_wx_set_frag,
+        IW_IOCTL(SIOCGIWFRAG)   = ipw_wx_get_frag,
+        IW_IOCTL(SIOCSIWTXPOW)  = ipw_wx_set_txpow,
+        IW_IOCTL(SIOCGIWTXPOW)  = ipw_wx_get_txpow,
+        IW_IOCTL(SIOCSIWRETRY)  = ipw_wx_set_retry,
+        IW_IOCTL(SIOCGIWRETRY)  = ipw_wx_get_retry,
+        IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
+        IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
+        IW_IOCTL(SIOCSIWPOWER)  = ipw_wx_set_power,
+        IW_IOCTL(SIOCGIWPOWER)  = ipw_wx_get_power,
 };
 
 #define IPW_PRIV_SET_POWER      SIOCIWFIRSTPRIV
@@ -6134,38 +6184,31 @@ static iw_handler ipw_wx_handlers[] =
 #define IPW_PRIV_SET_PROMISC    SIOCIWFIRSTPRIV+4
 #define IPW_PRIV_RESET          SIOCIWFIRSTPRIV+5
 
-
 static struct iw_priv_args ipw_priv_args[] = {
         {
-                .cmd = IPW_PRIV_SET_POWER,
-                .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
-                .name = "set_power"
-        },
+         .cmd = IPW_PRIV_SET_POWER,
+         .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         .name = "set_power"},
         {
-                .cmd = IPW_PRIV_GET_POWER,
-                .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
-                .name = "get_power"
-        },
+         .cmd = IPW_PRIV_GET_POWER,
+         .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
+         .name = "get_power"},
         {
-                .cmd = IPW_PRIV_SET_MODE,
-                .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
-                .name = "set_mode"
-        },
+         .cmd = IPW_PRIV_SET_MODE,
+         .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         .name = "set_mode"},
         {
-                .cmd = IPW_PRIV_GET_MODE,
-                .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
-                .name = "get_mode"
-        },
+         .cmd = IPW_PRIV_GET_MODE,
+         .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
+         .name = "get_mode"},
 #ifdef CONFIG_IPW_PROMISC
         {
-                IPW_PRIV_SET_PROMISC,
-                IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"
-        },
+         IPW_PRIV_SET_PROMISC,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
         {
-                IPW_PRIV_RESET,
-                IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"
-        },
-#endif /* CONFIG_IPW_PROMISC */
+         IPW_PRIV_RESET,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
+#endif                          /* CONFIG_IPW_PROMISC */
 };
 
 static iw_handler ipw_priv_handler[] = {
@@ -6179,25 +6222,21 @@ static iw_handler ipw_priv_handler[] = {
 #endif
 };
 
-static struct iw_handler_def ipw_wx_handler_def =
-{
-        .standard       = ipw_wx_handlers,
-        .num_standard   = ARRAY_SIZE(ipw_wx_handlers),
-        .num_private    = ARRAY_SIZE(ipw_priv_handler),
-        .num_private_args = ARRAY_SIZE(ipw_priv_args),
-        .private        = ipw_priv_handler,
-        .private_args   = ipw_priv_args,
+static struct iw_handler_def ipw_wx_handler_def = {
+        .standard               = ipw_wx_handlers,
+        .num_standard           = ARRAY_SIZE(ipw_wx_handlers),
+        .num_private            = ARRAY_SIZE(ipw_priv_handler),
+        .num_private_args       = ARRAY_SIZE(ipw_priv_args),
+        .private                = ipw_priv_handler,
+        .private_args           = ipw_priv_args,
 };
 
-
-
-
 /*
  * Get wireless statistics.
  * Called by /proc/net/wireless
  * Also called by SIOCGIWSTATS
  */
-static struct iw_statistics *ipw_get_wireless_stats(struct net_device * dev)
+static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
 {
         struct ipw_priv *priv = ieee80211_priv(dev);
         struct iw_statistics *wstats;
@@ -6217,7 +6256,7 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device * dev)
                 wstats->qual.noise = 0;
                 wstats->qual.updated = 7;
                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
-                        IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
+                    IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
                 return wstats;
         }
 
@@ -6225,7 +6264,7 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device * dev)
         wstats->qual.level = average_value(&priv->average_rssi);
         wstats->qual.noise = average_value(&priv->average_noise);
         wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
-                IW_QUAL_NOISE_UPDATED;
+            IW_QUAL_NOISE_UPDATED;
 
         wstats->miss.beacon = average_value(&priv->average_missed_beacons);
         wstats->discard.retries = priv->last_tx_failures;
@@ -6238,13 +6277,12 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device * dev)
         return wstats;
 }
 
-
 /* net device stuff */
 
 static inline void init_sys_config(struct ipw_sys_config *sys_config)
 {
-        memset(sys_config, 0, sizeof(struct ipw_sys_config));
-        sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
+        memset(sys_config, 0, sizeof(struct ipw_sys_config));
+        sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
         sys_config->answer_broadcast_ssid_probe = 0;
         sys_config->accept_all_data_frames = 0;
         sys_config->accept_non_directed_frames = 1;
@@ -6253,7 +6291,7 @@ static inline void init_sys_config(struct ipw_sys_config *sys_config)
         sys_config->exclude_multicast_unencrypted = 0;
         sys_config->disable_multicast_decryption = 1;
         sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
-        sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
+        sys_config->pass_crc_to_host = 0;       /* TODO: See if 1 gives us FCS */
         sys_config->dot11g_auto_detection = 0;
         sys_config->enable_cts_to_self = 0;
         sys_config->bt_coexist_collision_thr = 0;
@@ -6288,7 +6326,7 @@ we need to heavily modify the ieee80211_skb_to_txb.
 static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
 {
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)
-                txb->fragments[0]->data;
+            txb->fragments[0]->data;
         int i = 0;
         struct tfd_frame *tfd;
         struct clx2_tx_queue *txq = &priv->txq[0];
@@ -6300,7 +6338,7 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
         case IW_MODE_ADHOC:
                 hdr_len = IEEE80211_3ADDR_LEN;
                 unicast = !is_broadcast_ether_addr(hdr->addr1) &&
-                        !is_multicast_ether_addr(hdr->addr1);
+                    !is_multicast_ether_addr(hdr->addr1);
                 id = ipw_find_station(priv, hdr->addr1);
                 if (id == IPW_INVALID_STATION) {
                         id = ipw_add_station(priv, hdr->addr1);
@@ -6316,7 +6354,7 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
         case IW_MODE_INFRA:
         default:
                 unicast = !is_broadcast_ether_addr(hdr->addr3) &&
-                        !is_multicast_ether_addr(hdr->addr3);
+                    !is_multicast_ether_addr(hdr->addr3);
                 hdr_len = IEEE80211_3ADDR_LEN;
                 id = 0;
                 break;
@@ -6349,7 +6387,7 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
         memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
 
         /* payload */
-        tfd->u.data.num_chunks = min((u8)(NUM_TFD_CHUNKS - 2), txb->nr_frags);
+        tfd->u.data.num_chunks = min((u8) (NUM_TFD_CHUNKS - 2), txb->nr_frags);
         for (i = 0; i < tfd->u.data.num_chunks; i++) {
                 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
                              i, tfd->u.data.num_chunks,
@@ -6357,9 +6395,11 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
                 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
                            txb->fragments[i]->len - hdr_len);
 
-                tfd->u.data.chunk_ptr[i] = pci_map_single(
-                        priv->pci_dev, txb->fragments[i]->data + hdr_len,
-                        txb->fragments[i]->len - hdr_len, PCI_DMA_TODEVICE);
+                tfd->u.data.chunk_ptr[i] =
+                    pci_map_single(priv->pci_dev,
+                                   txb->fragments[i]->data + hdr_len,
+                                   txb->fragments[i]->len - hdr_len,
+                                   PCI_DMA_TODEVICE);
                 tfd->u.data.chunk_len[i] = txb->fragments[i]->len - hdr_len;
         }
 
@@ -6379,16 +6419,16 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
                         for (j = i; j < txb->nr_frags; j++) {
                                 int size = txb->fragments[j]->len - hdr_len;
                                 printk(KERN_INFO "Adding frag %d %d...\n",
-                                        j, size);
+                                       j, size);
                                 memcpy(skb_put(skb, size),
-                                        txb->fragments[j]->data + hdr_len,
-                                        size);
+                                       txb->fragments[j]->data + hdr_len, size);
                         }
                         dev_kfree_skb_any(txb->fragments[i]);
                         txb->fragments[i] = skb;
-                        tfd->u.data.chunk_ptr[i] = pci_map_single(
-                                priv->pci_dev, skb->data,
-                                tfd->u.data.chunk_len[i], PCI_DMA_TODEVICE);
+                        tfd->u.data.chunk_ptr[i] =
+                            pci_map_single(priv->pci_dev, skb->data,
+                                           tfd->u.data.chunk_len[i],
+                                           PCI_DMA_TODEVICE);
                         tfd->u.data.num_chunks++;
                 }
         }
@@ -6402,7 +6442,7 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
 
         return;
 
- drop:
+      drop:
         IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
         ieee80211_txb_free(txb);
 }
@@ -6429,7 +6469,7 @@ static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
         spin_unlock_irqrestore(&priv->lock, flags);
         return 0;
 
- fail_unlock:
+      fail_unlock:
         spin_unlock_irqrestore(&priv->lock, flags);
         return 1;
 }
@@ -6478,7 +6518,7 @@ static void ipw_ethtool_get_drvinfo(struct net_device *dev,
         len = sizeof(date);
         ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
 
-        snprintf(info->fw_version, sizeof(info->fw_version),"%s (%s)",
+        snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
                  vers, date);
         strcpy(info->bus_info, pci_name(p->pci_dev));
         info->eedump_len = CX2_EEPROM_IMAGE_SIZE;
@@ -6496,19 +6536,19 @@ static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
 }
 
 static int ipw_ethtool_get_eeprom(struct net_device *dev,
-                                  struct ethtool_eeprom *eeprom, u8 *bytes)
+                                  struct ethtool_eeprom *eeprom, u8 * bytes)
 {
         struct ipw_priv *p = ieee80211_priv(dev);
 
         if (eeprom->offset + eeprom->len > CX2_EEPROM_IMAGE_SIZE)
                 return -EINVAL;
 
-        memcpy(bytes, &((u8 *)p->eeprom)[eeprom->offset], eeprom->len);
+        memcpy(bytes, &((u8 *) p->eeprom)[eeprom->offset], eeprom->len);
         return 0;
 }
 
 static int ipw_ethtool_set_eeprom(struct net_device *dev,
-                                  struct ethtool_eeprom *eeprom, u8 *bytes)
+                                  struct ethtool_eeprom *eeprom, u8 * bytes)
 {
         struct ipw_priv *p = ieee80211_priv(dev);
         int i;
@@ -6516,21 +6556,20 @@ static int ipw_ethtool_set_eeprom(struct net_device *dev,
         if (eeprom->offset + eeprom->len > CX2_EEPROM_IMAGE_SIZE)
                 return -EINVAL;
 
-        memcpy(&((u8 *)p->eeprom)[eeprom->offset], bytes, eeprom->len);
+        memcpy(&((u8 *) p->eeprom)[eeprom->offset], bytes, eeprom->len);
         for (i = IPW_EEPROM_DATA;
-             i < IPW_EEPROM_DATA + CX2_EEPROM_IMAGE_SIZE;
-             i++)
+             i < IPW_EEPROM_DATA + CX2_EEPROM_IMAGE_SIZE; i++)
                 ipw_write8(p, i, p->eeprom[i]);
 
         return 0;
 }
 
 static struct ethtool_ops ipw_ethtool_ops = {
-         .get_link       = ipw_ethtool_get_link,
-         .get_drvinfo    = ipw_ethtool_get_drvinfo,
-         .get_eeprom_len = ipw_ethtool_get_eeprom_len,
-         .get_eeprom     = ipw_ethtool_get_eeprom,
-         .set_eeprom     = ipw_ethtool_set_eeprom,
+        .get_link       = ipw_ethtool_get_link,
+        .get_drvinfo    = ipw_ethtool_get_drvinfo,
+        .get_eeprom_len = ipw_ethtool_get_eeprom_len,
+        .get_eeprom     = ipw_ethtool_get_eeprom,
+        .set_eeprom     = ipw_ethtool_set_eeprom,
 };
 
 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
@@ -6574,10 +6613,10 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
 
         tasklet_schedule(&priv->irq_tasklet);
 
-        spin_unlock(&priv->lock);
+        spin_unlock(&priv->lock);
 
         return IRQ_HANDLED;
- none:
+      none:
         spin_unlock(&priv->lock);
         return IRQ_NONE;
 }
@@ -6609,7 +6648,7 @@ static void ipw_rf_kill(void *adapter)
                 IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
                                   "enabled\n");
 
- exit_unlock:
+      exit_unlock:
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
@@ -6642,7 +6681,6 @@ static int ipw_setup_deferred_work(struct ipw_priv *priv)
         return ret;
 }
 
-
 static void shim__set_security(struct net_device *dev,
                                struct ieee80211_security *sec)
 {
@@ -6683,8 +6721,7 @@ static void shim__set_security(struct net_device *dev,
                 priv->status |= STATUS_SECURITY_UPDATED;
         }
 
-        if (sec->flags & SEC_ENABLED &&
-            priv->sec.enabled != sec->enabled) {
+        if (sec->flags & SEC_ENABLED && priv->sec.enabled != sec->enabled) {
                 priv->sec.flags |= SEC_ENABLED;
                 priv->sec.enabled = sec->enabled;
                 priv->status |= STATUS_SECURITY_UPDATED;
@@ -6694,8 +6731,7 @@ static void shim__set_security(struct net_device *dev,
                         priv->capability &= ~CAP_PRIVACY_ON;
         }
 
-        if (sec->flags & SEC_LEVEL &&
-            priv->sec.level != sec->level) {
+        if (sec->flags & SEC_LEVEL && priv->sec.level != sec->level) {
                 priv->sec.level = sec->level;
                 priv->sec.flags |= SEC_LEVEL;
                 priv->status |= STATUS_SECURITY_UPDATED;
@@ -6709,7 +6745,7 @@ static void shim__set_security(struct net_device *dev,
             (((priv->assoc_request.capability &
                WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
              (!(priv->assoc_request.capability &
-                 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
+                WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
                 IPW_DEBUG_ASSOC("Disassociating due to capability "
                                 "change.\n");
                 ipw_disassociate(priv);
@@ -6723,7 +6759,7 @@ static int init_supported_rates(struct ipw_priv *priv,
         /* TODO: Mask out rates based on priv->rates_mask */
 
         memset(rates, 0, sizeof(*rates));
-        /* configure supported rates */
+        /* configure supported rates */
         switch (priv->ieee->freq_band) {
         case IEEE80211_52GHZ_BAND:
                 rates->ieee_mode = IPW_A_MODE;
@@ -6732,7 +6768,7 @@ static int init_supported_rates(struct ipw_priv *priv,
                                         IEEE80211_OFDM_DEFAULT_RATES_MASK);
                 break;
 
-        default: /* Mixed or 2.4Ghz */
+        default:                /* Mixed or 2.4Ghz */
                 rates->ieee_mode = IPW_G_MODE;
                 rates->purpose = IPW_RATE_CAPABILITIES;
                 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
@@ -6783,8 +6819,8 @@ static int ipw_config(struct ipw_priv *priv)
         if (ipw_send_system_config(priv, &priv->sys_config))
                 goto error;
 
-        init_supported_rates(priv, &priv->rates);
-        if (ipw_send_supported_rates(priv, &priv->rates))
+        init_supported_rates(priv, &priv->rates);
+        if (ipw_send_supported_rates(priv, &priv->rates))
                 goto error;
 
         /* Set request-to-send threshold */
@@ -6806,7 +6842,7 @@ static int ipw_config(struct ipw_priv *priv)
 
         return 0;
 
- error:
+      error:
         return -EIO;
 }
 
@@ -6818,13 +6854,12 @@ static int ipw_up(struct ipw_priv *priv)
         if (priv->status & STATUS_EXIT_PENDING)
                 return -EIO;
 
-        for (i = 0; i < MAX_HW_RESTARTS; i++ ) {
+        for (i = 0; i < MAX_HW_RESTARTS; i++) {
                 /* Load the microcode, firmware, and eeprom.
                  * Also start the clocks. */
                 rc = ipw_load(priv);
                 if (rc) {
-                        IPW_ERROR("Unable to load firmware: 0x%08X\n",
-                                        rc);
+                        IPW_ERROR("Unable to load firmware: 0x%08X\n", rc);
                         return rc;
                 }
 
@@ -6857,8 +6892,7 @@ static int ipw_up(struct ipw_priv *priv)
 
         /* tried to restart and config the device for as long as our
          * patience could withstand */
-        IPW_ERROR("Unable to initialize device after %d attempts.\n",
-                  i);
+        IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
         return -EIO;
 }
 
@@ -6923,10 +6957,10 @@ static struct pci_device_id card_ids[] = {
         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
         {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
-        {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* 2225BG */
-        {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
-        {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
+        {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
+        {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* 2225BG */
+        {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
+        {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
 
         /* required last entry */
         {0,}
@@ -6954,11 +6988,10 @@ static struct attribute *ipw_sysfs_entries[] = {
 
 static struct attribute_group ipw_attribute_group = {
         .name = NULL,           /* put in device directory */
-        .attrs  = ipw_sysfs_entries,
+        .attrs = ipw_sysfs_entries,
 };
 
-static int ipw_pci_probe(struct pci_dev *pdev,
-                         const struct pci_device_id *ent)
+static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         int err = 0;
         struct net_device *net_dev;
@@ -7051,7 +7084,7 @@ static int ipw_pci_probe(struct pci_dev *pdev,
                 priv->config |= CFG_STATIC_CHANNEL;
                 priv->channel = channel;
                 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
-                IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
+                IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
                 /* TODO: Validate that provided channel is in range */
         }
 
@@ -7078,9 +7111,9 @@ static int ipw_pci_probe(struct pci_dev *pdev,
                 priv->ieee->abg_ture = 1;
                 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
                 modulation = IEEE80211_OFDM_MODULATION |
-                        IEEE80211_CCK_MODULATION;
+                    IEEE80211_CCK_MODULATION;
                 priv->adapter = IPW_2915ABG;
-                priv->ieee->mode = IEEE_A|IEEE_G|IEEE_B;
+                priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
         } else {
                 if (priv->pci_dev->device == 0x4221)
                         printk(KERN_INFO DRV_NAME
@@ -7094,9 +7127,9 @@ static int ipw_pci_probe(struct pci_dev *pdev,
                 priv->ieee->abg_ture = 0;
                 band = IEEE80211_24GHZ_BAND;
                 modulation = IEEE80211_OFDM_MODULATION |
-                        IEEE80211_CCK_MODULATION;
+                    IEEE80211_CCK_MODULATION;
                 priv->adapter = IPW_2200BG;
-                priv->ieee->mode = IEEE_G|IEEE_B;
+                priv->ieee->mode = IEEE_G | IEEE_B;
         }
 
         priv->ieee->freq_band = band;
@@ -7110,11 +7143,10 @@ static int ipw_pci_probe(struct pci_dev *pdev,
         priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
 
         /* If power management is turned on, default to AC mode */
-        priv->power_mode = IPW_POWER_AC;
+        priv->power_mode = IPW_POWER_AC;
         priv->tx_power = IPW_DEFAULT_TX_POWER;
 
-        err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME,
-                          priv);
+        err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
         if (err) {
                 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
                 goto out_destroy_workqueue;
@@ -7136,7 +7168,7 @@ static int ipw_pci_probe(struct pci_dev *pdev,
         net_dev->wireless_handlers = &ipw_wx_handler_def;
         net_dev->ethtool_ops = &ipw_ethtool_ops;
         net_dev->irq = pdev->irq;
-        net_dev->base_addr = (unsigned long )priv->hw_base;
+        net_dev->base_addr = (unsigned long)priv->hw_base;
         net_dev->mem_start = pci_resource_start(pdev, 0);
         net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
 
@@ -7154,23 +7186,23 @@ static int ipw_pci_probe(struct pci_dev *pdev,
 
         return 0;
 
- out_remove_group:
+      out_remove_group:
         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
- out_release_irq:
+      out_release_irq:
         free_irq(pdev->irq, priv);
- out_destroy_workqueue:
+      out_destroy_workqueue:
         destroy_workqueue(priv->workqueue);
         priv->workqueue = NULL;
- out_iounmap:
+      out_iounmap:
         iounmap(priv->hw_base);
- out_pci_release_regions:
+      out_pci_release_regions:
         pci_release_regions(pdev);
- out_pci_disable_device:
+      out_pci_disable_device:
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
- out_free_ieee80211:
+      out_free_ieee80211:
         free_ieee80211(priv->net_dev);
- out:
+      out:
         return err;
 }
 
@@ -7223,7 +7255,6 @@ static void ipw_pci_remove(struct pci_dev *pdev)
 #endif
 }
 
-
 #ifdef CONFIG_PM
 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -7232,7 +7263,7 @@ static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 
         printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
 
-        /* Take down the device; powers it off, etc. */
+        /* Take down the device; powers it off, etc. */
         ipw_down(priv);
 
         /* Remove the PRESENT state of the device */
@@ -7306,8 +7337,7 @@ static int __init ipw_init(void)
                 return ret;
         }
 
-        ret = driver_create_file(&ipw_driver.driver,
-                                 &driver_attr_debug_level);
+        ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
         if (ret) {
                 IPW_ERROR("Unable to create driver sysfs file\n");
                 pci_unregister_driver(&ipw_driver);
diff --git a/drivers/net/wireless/ipw2200.h b/drivers/net/wireless/ipw2200.h
index 66bb5903537f..5b00882133f9 100644
--- a/drivers/net/wireless/ipw2200.h
+++ b/drivers/net/wireless/ipw2200.h
@@ -56,8 +56,7 @@
 #include <linux/workqueue.h>
 
 /* Authentication  and Association States */
-enum connection_manager_assoc_states
-{
+enum connection_manager_assoc_states {
         CMAS_INIT = 0,
         CMAS_TX_AUTH_SEQ_1,
         CMAS_RX_AUTH_SEQ_2,
@@ -74,7 +73,6 @@ enum connection_manager_assoc_states
         CMAS_LAST
 };
 
-
 #define IPW_WAIT                     (1<<0)
 #define IPW_QUIET                    (1<<1)
 #define IPW_ROAMING                  (1<<2)
@@ -190,7 +188,6 @@ enum connection_manager_assoc_states
 #define DCT_FLAG_EXT_MODE_CCK  0x01
 #define DCT_FLAG_EXT_MODE_OFDM 0x00
 
-
 #define TX_RX_TYPE_MASK                    0xFF
 #define TX_FRAME_TYPE                      0x00
 #define TX_HOST_COMMAND_TYPE               0x01
@@ -242,107 +239,97 @@ enum connection_manager_assoc_states
  * Contains common data for Rx and Tx queues
  */
 struct clx2_queue {
-        int n_bd;                      /**< number of BDs in this queue */
-        int first_empty;               /**< 1-st empty entry (index) */
-        int last_used;                 /**< last used entry (index) */
-        u32 reg_w;                   /**< 'write' reg (queue head), addr in domain 1 */
-        u32 reg_r;                   /**< 'read' reg (queue tail), addr in domain 1 */
-        dma_addr_t dma_addr;            /**< physical addr for BD's */
-        int low_mark;                  /**< low watermark, resume queue if free space more than this */
-        int high_mark;                 /**< high watermark, stop queue if free space less than this */
+        int n_bd;                      /**< number of BDs in this queue */
+        int first_empty;               /**< 1-st empty entry (index) */
+        int last_used;                 /**< last used entry (index) */
+        u32 reg_w;                   /**< 'write' reg (queue head), addr in domain 1 */
+        u32 reg_r;                   /**< 'read' reg (queue tail), addr in domain 1 */
+        dma_addr_t dma_addr;            /**< physical addr for BD's */
+        int low_mark;                  /**< low watermark, resume queue if free space more than this */
+        int high_mark;                 /**< high watermark, stop queue if free space less than this */
 } __attribute__ ((packed));
 
-struct machdr32
-{
+struct machdr32 {
         u16 frame_ctl;
-        u16 duration;     // watch out for endians!
-        u8 addr1[ MACADRR_BYTE_LEN ];
-        u8 addr2[ MACADRR_BYTE_LEN ];
-        u8 addr3[ MACADRR_BYTE_LEN ];
-        u16 seq_ctrl;     // more endians!
-        u8 addr4[ MACADRR_BYTE_LEN ];
+        u16 duration;           // watch out for endians!
+        u8 addr1[MACADRR_BYTE_LEN];
+        u8 addr2[MACADRR_BYTE_LEN];
+        u8 addr3[MACADRR_BYTE_LEN];
+        u16 seq_ctrl;           // more endians!
+        u8 addr4[MACADRR_BYTE_LEN];
         u16 qos_ctrl;
-} __attribute__ ((packed)) ;
+} __attribute__ ((packed));
 
-struct machdr30
-{
+struct machdr30 {
         u16 frame_ctl;
-        u16 duration;     // watch out for endians!
-        u8 addr1[ MACADRR_BYTE_LEN ];
-        u8 addr2[ MACADRR_BYTE_LEN ];
-        u8 addr3[ MACADRR_BYTE_LEN ];
-        u16 seq_ctrl;     // more endians!
-        u8 addr4[ MACADRR_BYTE_LEN ];
-} __attribute__ ((packed)) ;
-
-struct machdr26
-{
+        u16 duration;           // watch out for endians!
+        u8 addr1[MACADRR_BYTE_LEN];
+        u8 addr2[MACADRR_BYTE_LEN];
+        u8 addr3[MACADRR_BYTE_LEN];
+        u16 seq_ctrl;           // more endians!
+        u8 addr4[MACADRR_BYTE_LEN];
+} __attribute__ ((packed));
+
+struct machdr26 {
         u16 frame_ctl;
-        u16 duration;     // watch out for endians!
-        u8 addr1[ MACADRR_BYTE_LEN ];
-        u8 addr2[ MACADRR_BYTE_LEN ];
-        u8 addr3[ MACADRR_BYTE_LEN ];
-        u16 seq_ctrl;     // more endians!
+        u16 duration;           // watch out for endians!
+        u8 addr1[MACADRR_BYTE_LEN];
+        u8 addr2[MACADRR_BYTE_LEN];
+        u8 addr3[MACADRR_BYTE_LEN];
+        u16 seq_ctrl;           // more endians!
         u16 qos_ctrl;
-} __attribute__ ((packed)) ;
+} __attribute__ ((packed));
 
-struct machdr24
-{
+struct machdr24 {
         u16 frame_ctl;
-        u16 duration;     // watch out for endians!
-        u8 addr1[ MACADRR_BYTE_LEN ];
-        u8 addr2[ MACADRR_BYTE_LEN ];
-        u8 addr3[ MACADRR_BYTE_LEN ];
-        u16 seq_ctrl;     // more endians!
-} __attribute__ ((packed)) ;
+        u16 duration;           // watch out for endians!
+        u8 addr1[MACADRR_BYTE_LEN];
+        u8 addr2[MACADRR_BYTE_LEN];
+        u8 addr3[MACADRR_BYTE_LEN];
+        u16 seq_ctrl;           // more endians!
+} __attribute__ ((packed));
 
 // TX TFD with 32 byte MAC Header
-struct tx_tfd_32
-{
-        struct machdr32    mchdr;                      // 32
-        u32                uivplaceholder[2];          // 8
-} __attribute__ ((packed)) ;
+struct tx_tfd_32 {
+        struct machdr32 mchdr;  // 32
+        u32 uivplaceholder[2];  // 8
+} __attribute__ ((packed));
 
 // TX TFD with 30 byte MAC Header
-struct tx_tfd_30
-{
-        struct machdr30    mchdr;                      // 30
-        u8                 reserved[2];                // 2
-        u32                uivplaceholder[2];          // 8
-} __attribute__ ((packed)) ;
+struct tx_tfd_30 {
+        struct machdr30 mchdr;  // 30
+        u8 reserved[2];         // 2
+        u32 uivplaceholder[2];  // 8
+} __attribute__ ((packed));
 
 // tx tfd with 26 byte mac header
-struct tx_tfd_26
-{
-        struct machdr26    mchdr;                      // 26
-        u8                 reserved1[2];               // 2
-        u32                uivplaceholder[2];          // 8
-        u8                 reserved2[4];               // 4
-} __attribute__ ((packed)) ;
+struct tx_tfd_26 {
+        struct machdr26 mchdr;  // 26
+        u8 reserved1[2];        // 2
+        u32 uivplaceholder[2];  // 8
+        u8 reserved2[4];        // 4
+} __attribute__ ((packed));
 
 // tx tfd with 24 byte mac header
-struct tx_tfd_24
-{
-        struct machdr24    mchdr;                      // 24
-        u32                uivplaceholder[2];          // 8
-        u8                 reserved[8];                // 8
-} __attribute__ ((packed)) ;
-
+struct tx_tfd_24 {
+        struct machdr24 mchdr;  // 24
+        u32 uivplaceholder[2];  // 8
+        u8 reserved[8];         // 8
+} __attribute__ ((packed));
 
 #define DCT_WEP_KEY_FIELD_LENGTH 16
 
-struct tfd_command
-{
+struct tfd_command {
         u8 index;
         u8 length;
         u16 reserved;
         u8 payload[0];
-} __attribute__ ((packed)) ;
+} __attribute__ ((packed));
 
 struct tfd_data {
         /* Header */
         u32 work_area_ptr;
-        u8 station_number; /* 0 for BSS */
+        u8 station_number;      /* 0 for BSS */
         u8 reserved1;
         u16 reserved2;
 
@@ -359,14 +346,13 @@ struct tfd_data {
         u8 antenna;
         u16 next_packet_duration;
         u16 next_frag_len;
-        u16 back_off_counter; //////txop;
+        u16 back_off_counter;   //////txop;
         u8 retrylimit;
         u16 cwcurrent;
         u8 reserved3;
 
         /* 802.11 MAC Header */
-        union
-        {
+        union {
                 struct tx_tfd_24 tfd_24;
                 struct tx_tfd_26 tfd_26;
                 struct tx_tfd_30 tfd_30;
@@ -379,8 +365,7 @@ struct tfd_data {
         u16 chunk_len[NUM_TFD_CHUNKS];
 } __attribute__ ((packed));
 
-struct txrx_control_flags
-{
+struct txrx_control_flags {
         u8 message_type;
         u8 rx_seq_num;
         u8 control_bits;
@@ -390,17 +375,16 @@ struct txrx_control_flags
 #define  TFD_SIZE                           128
 #define  TFD_CMD_IMMEDIATE_PAYLOAD_LENGTH   (TFD_SIZE - sizeof(struct txrx_control_flags))
 
-struct tfd_frame
-{
+struct tfd_frame {
         struct txrx_control_flags control_flags;
         union {
                 struct tfd_data data;
                 struct tfd_command cmd;
                 u8 raw[TFD_CMD_IMMEDIATE_PAYLOAD_LENGTH];
         } u;
-} __attribute__ ((packed)) ;
+} __attribute__ ((packed));
 
-typedef void destructor_func(const void*);
+typedef void destructor_func(const void *);
 
 /**
  * Tx Queue for DMA. Queue consists of circular buffer of
@@ -408,7 +392,7 @@ typedef void destructor_func(const void*);
  */
 struct clx2_tx_queue {
         struct clx2_queue q;
-        struct tfd_frame* bd;
+        struct tfd_frame *bd;
         struct ieee80211_txb **txb;
 };
 
@@ -423,8 +407,7 @@ struct clx2_tx_queue {
 #define SUP_RATE_11G_MAX_NUM_CHANNELS  (12)
 
 // Used for passing to driver number of successes and failures per rate
-struct rate_histogram
-{
+struct rate_histogram {
         union {
                 u32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
                 u32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
@@ -475,12 +458,12 @@ struct notif_scan_complete {
         u8 num_channels;
         u8 status;
         u8 reserved;
-}  __attribute__ ((packed));
+} __attribute__ ((packed));
 
 struct notif_frag_length {
         u16 frag_length;
         u16 reserved;
-}  __attribute__ ((packed));
+} __attribute__ ((packed));
 
 struct notif_beacon_state {
         u32 state;
@@ -543,11 +526,11 @@ struct ipw_rx_notification {
 
 struct ipw_rx_frame {
         u32 reserved1;
-        u8 parent_tsf[4];     // fw_use[0] is boolean for OUR_TSF_IS_GREATER
-        u8 received_channel;  // The channel that this frame was received on.
-                              // Note that for .11b this does not have to be
-                              // the same as the channel that it was sent.
-                              // Filled by LMAC
+        u8 parent_tsf[4];       // fw_use[0] is boolean for OUR_TSF_IS_GREATER
+        u8 received_channel;    // The channel that this frame was received on.
+        // Note that for .11b this does not have to be
+        // the same as the channel that it was sent.
+        // Filled by LMAC
         u8 frameStatus;
         u8 rate;
         u8 rssi;
@@ -556,10 +539,10 @@ struct ipw_rx_frame {
         u16 signal;
         u16 noise;
         u8 antennaAndPhy;
-        u8 control;           // control bit should be on in bg
-        u8 rtscts_rate;       // rate of rts or cts (in rts cts sequence rate
-                              // is identical)
-        u8 rtscts_seen;       // 0x1 RTS seen ; 0x2 CTS seen
+        u8 control;             // control bit should be on in bg
+        u8 rtscts_rate;         // rate of rts or cts (in rts cts sequence rate
+        // is identical)
+        u8 rtscts_seen;         // 0x1 RTS seen ; 0x2 CTS seen
         u16 length;
         u8 data[0];
 } __attribute__ ((packed));
@@ -571,8 +554,7 @@ struct ipw_rx_header {
         u8 reserved;
 } __attribute__ ((packed));
 
-struct ipw_rx_packet
-{
+struct ipw_rx_packet {
         struct ipw_rx_header header;
         union {
                 struct ipw_rx_frame frame;
@@ -589,21 +571,20 @@ struct ipw_rx_mem_buffer {
         struct ipw_rx_buffer *rxb;
         struct sk_buff *skb;
         struct list_head list;
-}; /* Not transferred over network, so not  __attribute__ ((packed)) */
+};                              /* Not transferred over network, so not  __attribute__ ((packed)) */
 
 struct ipw_rx_queue {
         struct ipw_rx_mem_buffer pool[RX_QUEUE_SIZE + RX_FREE_BUFFERS];
         struct ipw_rx_mem_buffer *queue[RX_QUEUE_SIZE];
-        u32 processed; /* Internal index to last handled Rx packet */
-        u32 read;      /* Shared index to newest available Rx buffer */
-        u32 write;     /* Shared index to oldest written Rx packet */
-        u32 free_count;/* Number of pre-allocated buffers in rx_free */
+        u32 processed;          /* Internal index to last handled Rx packet */
+        u32 read;               /* Shared index to newest available Rx buffer */
+        u32 write;              /* Shared index to oldest written Rx packet */
+        u32 free_count;         /* Number of pre-allocated buffers in rx_free */
         /* Each of these lists is used as a FIFO for ipw_rx_mem_buffers */
-        struct list_head rx_free;  /* Own an SKBs */
-        struct list_head rx_used;  /* No SKB allocated */
+        struct list_head rx_free;       /* Own an SKBs */
+        struct list_head rx_used;       /* No SKB allocated */
         spinlock_t lock;
-}; /* Not transferred over network, so not  __attribute__ ((packed)) */
-
+};                              /* Not transferred over network, so not  __attribute__ ((packed)) */
 
 struct alive_command_responce {
         u8 alive_command;
@@ -627,8 +608,7 @@ struct ipw_rates {
         u8 rates[IPW_MAX_RATES];
 } __attribute__ ((packed));
 
-struct command_block
-{
+struct command_block {
         unsigned int control;
         u32 source_addr;
         u32 dest_addr;
@@ -636,18 +616,16 @@ struct command_block
 } __attribute__ ((packed));
 
 #define CB_NUMBER_OF_ELEMENTS_SMALL 64
-struct fw_image_desc
-{
+struct fw_image_desc {
         unsigned long last_cb_index;
         unsigned long current_cb_index;
         struct command_block cb_list[CB_NUMBER_OF_ELEMENTS_SMALL];
-        void * v_addr;
+        void *v_addr;
         unsigned long p_addr;
         unsigned long len;
 };
 
-struct ipw_sys_config
-{
+struct ipw_sys_config {
         u8 bt_coexistence;
         u8 reserved1;
         u8 answer_broadcast_ssid_probe;
@@ -670,8 +648,7 @@ struct ipw_sys_config
         u8 reserved3;
 } __attribute__ ((packed));
 
-struct ipw_multicast_addr
-{
+struct ipw_multicast_addr {
         u8 num_of_multicast_addresses;
         u8 reserved[3];
         u8 mac1[6];
@@ -680,8 +657,7 @@ struct ipw_multicast_addr
         u8 mac4[6];
 } __attribute__ ((packed));
 
-struct ipw_wep_key
-{
+struct ipw_wep_key {
         u8 cmd_id;
         u8 seq_num;
         u8 key_index;
@@ -689,8 +665,7 @@ struct ipw_wep_key
         u8 key[16];
 } __attribute__ ((packed));
 
-struct ipw_tgi_tx_key
-{
+struct ipw_tgi_tx_key {
         u8 key_id;
         u8 security_type;
         u8 station_index;
@@ -701,8 +676,7 @@ struct ipw_tgi_tx_key
 
 #define IPW_SCAN_CHANNELS 54
 
-struct ipw_scan_request
-{
+struct ipw_scan_request {
         u8 scan_type;
         u16 dwell_time;
         u8 channels_list[IPW_SCAN_CHANNELS];
@@ -718,8 +692,7 @@ enum {
         IPW_SCAN_TYPES
 };
 
-struct ipw_scan_request_ext
-{
+struct ipw_scan_request_ext {
         u32 full_scan_index;
         u8 channels_list[IPW_SCAN_CHANNELS];
         u8 scan_type[IPW_SCAN_CHANNELS / 2];
@@ -740,19 +713,16 @@ extern inline void ipw_set_scan_type(struct ipw_scan_request_ext *scan,
 {
         if (index % 2)
                 scan->scan_type[index / 2] =
-                        (scan->scan_type[index / 2] & 0xF0) |
-                        (scan_type & 0x0F);
+                    (scan->scan_type[index / 2] & 0xF0) | (scan_type & 0x0F);
         else
                 scan->scan_type[index / 2] =
-                        (scan->scan_type[index / 2] & 0x0F) |
-                        ((scan_type & 0x0F) << 4);
+                    (scan->scan_type[index / 2] & 0x0F) |
+                    ((scan_type & 0x0F) << 4);
 }
 
-struct ipw_associate
-{
+struct ipw_associate {
         u8 channel;
-        u8 auth_type:4,
-           auth_key:4;
+        u8 auth_type:4, auth_key:4;
         u8 assoc_type;
         u8 reserved;
         u16 policy_support;
@@ -771,8 +741,7 @@ struct ipw_associate
         u16 reserved2;
 } __attribute__ ((packed));
 
-struct ipw_supported_rates
-{
+struct ipw_supported_rates {
         u8 ieee_mode;
         u8 num_rates;
         u8 purpose;
@@ -780,42 +749,36 @@ struct ipw_supported_rates
         u8 supported_rates[IPW_MAX_RATES];
 } __attribute__ ((packed));
 
-struct ipw_rts_threshold
-{
+struct ipw_rts_threshold {
         u16 rts_threshold;
         u16 reserved;
 } __attribute__ ((packed));
 
-struct ipw_frag_threshold
-{
+struct ipw_frag_threshold {
         u16 frag_threshold;
         u16 reserved;
 } __attribute__ ((packed));
 
-struct ipw_retry_limit
-{
+struct ipw_retry_limit {
         u8 short_retry_limit;
         u8 long_retry_limit;
         u16 reserved;
 } __attribute__ ((packed));
 
-struct ipw_dino_config
-{
+struct ipw_dino_config {
         u32 dino_config_addr;
         u16 dino_config_size;
         u8 dino_response;
         u8 reserved;
 } __attribute__ ((packed));
 
-struct ipw_aironet_info
-{
+struct ipw_aironet_info {
         u8 id;
         u8 length;
         u16 reserved;
 } __attribute__ ((packed));
 
-struct ipw_rx_key
-{
+struct ipw_rx_key {
         u8 station_index;
         u8 key_type;
         u8 key_id;
@@ -826,23 +789,20 @@ struct ipw_rx_key
         u8 reserved;
 } __attribute__ ((packed));
 
-struct ipw_country_channel_info
-{
+struct ipw_country_channel_info {
         u8 first_channel;
         u8 no_channels;
         s8 max_tx_power;
 } __attribute__ ((packed));
 
-struct ipw_country_info
-{
+struct ipw_country_info {
         u8 id;
         u8 length;
         u8 country_str[3];
         struct ipw_country_channel_info groups[7];
 } __attribute__ ((packed));
 
-struct ipw_channel_tx_power
-{
+struct ipw_channel_tx_power {
         u8 channel_number;
         s8 tx_power;
 } __attribute__ ((packed));
@@ -852,15 +812,13 @@ struct ipw_channel_tx_power
 #define MAX_A_CHANNELS  37
 #define MAX_B_CHANNELS  14
 
-struct ipw_tx_power
-{
+struct ipw_tx_power {
         u8 num_channels;
         u8 ieee_mode;
         struct ipw_channel_tx_power channels_tx_power[MAX_A_CHANNELS];
 } __attribute__ ((packed));
 
-struct ipw_qos_parameters
-{
+struct ipw_qos_parameters {
         u16 cw_min[4];
         u16 cw_max[4];
         u8 aifs[4];
@@ -868,15 +826,13 @@ struct ipw_qos_parameters
         u16 tx_op_limit[4];
 } __attribute__ ((packed));
 
-struct ipw_rsn_capabilities
-{
+struct ipw_rsn_capabilities {
         u8 id;
         u8 length;
         u16 version;
 } __attribute__ ((packed));
 
-struct ipw_sensitivity_calib
-{
+struct ipw_sensitivity_calib {
         u16 beacon_rssi_raw;
         u16 reserved;
 } __attribute__ ((packed));
@@ -895,10 +851,11 @@ struct ipw_sensitivity_calib
  * - \a param filled with status parameters.
  */
 struct ipw_cmd {
-  u32 cmd;         /**< Host command */
-  u32 status;      /**< Status */
-  u32 status_len;  /**< How many 32 bit parameters in the status */
-  u32 len;         /**< incoming parameters length, bytes */
+        u32 cmd;   /**< Host command */
+        u32 status;/**< Status */
+        u32 status_len;
+                   /**< How many 32 bit parameters in the status */
+        u32 len;   /**< incoming parameters length, bytes */
   /**
    * command parameters.
    * There should be enough space for incoming and
@@ -906,10 +863,10 @@ struct ipw_cmd {
    * Incoming parameters listed 1-st, followed by outcoming params.
    * nParams=(len+3)/4+status_len
    */
-  u32 param[0];
+        u32 param[0];
 } __attribute__ ((packed));
 
-#define STATUS_HCMD_ACTIVE      (1<<0)  /**< host command in progress */
+#define STATUS_HCMD_ACTIVE      (1<<0)  /**< host command in progress */
 
 #define STATUS_INT_ENABLED      (1<<1)
 #define STATUS_RF_KILL_HW       (1<<2)
@@ -932,15 +889,15 @@ struct ipw_cmd {
 #define STATUS_SCANNING         (1<<21)
 #define STATUS_SCAN_ABORTING    (1<<22)
 
-#define STATUS_INDIRECT_BYTE    (1<<28) /* sysfs entry configured for access */
-#define STATUS_INDIRECT_DWORD   (1<<29) /* sysfs entry configured for access */
-#define STATUS_DIRECT_DWORD     (1<<30) /* sysfs entry configured for access */
+#define STATUS_INDIRECT_BYTE    (1<<28) /* sysfs entry configured for access */
+#define STATUS_INDIRECT_DWORD   (1<<29) /* sysfs entry configured for access */
+#define STATUS_DIRECT_DWORD     (1<<30) /* sysfs entry configured for access */
 
-#define STATUS_SECURITY_UPDATED (1<<31) /* Security sync needed */
+#define STATUS_SECURITY_UPDATED (1<<31) /* Security sync needed */
 
-#define CFG_STATIC_CHANNEL      (1<<0) /* Restrict assoc. to single channel */
-#define CFG_STATIC_ESSID        (1<<1) /* Restrict assoc. to single SSID */
-#define CFG_STATIC_BSSID        (1<<2) /* Restrict assoc. to single BSSID */
+#define CFG_STATIC_CHANNEL      (1<<0)  /* Restrict assoc. to single channel */
+#define CFG_STATIC_ESSID        (1<<1)  /* Restrict assoc. to single SSID */
+#define CFG_STATIC_BSSID        (1<<2)  /* Restrict assoc. to single BSSID */
 #define CFG_CUSTOM_MAC          (1<<3)
 #define CFG_PREAMBLE            (1<<4)
 #define CFG_ADHOC_PERSIST       (1<<5)
@@ -948,8 +905,8 @@ struct ipw_cmd {
 #define CFG_FIXED_RATE          (1<<7)
 #define CFG_ADHOC_CREATE        (1<<8)
 
-#define CAP_SHARED_KEY          (1<<0) /* Off = OPEN */
-#define CAP_PRIVACY_ON          (1<<1) /* Off = No privacy */
+#define CAP_SHARED_KEY          (1<<0)  /* Off = OPEN */
+#define CAP_PRIVACY_ON          (1<<1)  /* Off = No privacy */
 
 #define MAX_STATIONS            32
 #define IPW_INVALID_STATION     (0xff)
@@ -989,8 +946,8 @@ struct ipw_priv {
         /* result of ucode download */
         struct alive_command_responce dino_alive;
 
-        wait_queue_head_t wait_command_queue;
-        wait_queue_head_t wait_state;
+        wait_queue_head_t wait_command_queue;
+        wait_queue_head_t wait_state;
 
         /* Rx and Tx DMA processing queues */
         struct ipw_rx_queue *rxq;
@@ -1006,9 +963,9 @@ struct ipw_priv {
         struct average average_rssi;
         struct average average_noise;
         u32 port_type;
-        int rx_bufs_min;          /**< minimum number of bufs in Rx queue */
-        int rx_pend_max;          /**< maximum pending buffers for one IRQ */
-        u32 hcmd_seq;             /**< sequence number for hcmd */
+        int rx_bufs_min;          /**< minimum number of bufs in Rx queue */
+        int rx_pend_max;          /**< maximum pending buffers for one IRQ */
+        u32 hcmd_seq;             /**< sequence number for hcmd */
         u32 missed_beacon_threshold;
         u32 roaming_threshold;
 
@@ -1017,17 +974,17 @@ struct ipw_priv {
 
         unsigned long ts_scan_abort;
         struct ipw_supported_rates rates;
-        struct ipw_rates phy[3];           /**< PHY restrictions, per band */
-        struct ipw_rates supp;             /**< software defined */
-        struct ipw_rates extended;         /**< use for corresp. IE, AP only */
+        struct ipw_rates phy[3];           /**< PHY restrictions, per band */
+        struct ipw_rates supp;             /**< software defined */
+        struct ipw_rates extended;         /**< use for corresp. IE, AP only */
 
         struct notif_link_deterioration last_link_deterioration; /** for statistics */
-        struct ipw_cmd* hcmd; /**< host command currently executed */
+        struct ipw_cmd *hcmd; /**< host command currently executed */
 
         wait_queue_head_t hcmd_wq;     /**< host command waits for execution */
-        u32 tsf_bcn[2];              /**< TSF from latest beacon */
+        u32 tsf_bcn[2];              /**< TSF from latest beacon */
 
-        struct notif_calibration calib; /**< last calibration */
+        struct notif_calibration calib; /**< last calibration */
 
         /* ordinal interface with firmware */
         u32 table0_addr;
@@ -1067,8 +1024,8 @@ struct ipw_priv {
         u32 tx_packets;
         u32 quality;
 
-        /* eeprom */
-        u8 eeprom[0x100];  /* 256 bytes of eeprom */
+        /* eeprom */
+        u8 eeprom[0x100];       /* 256 bytes of eeprom */
         int eeprom_delay;
 
         struct iw_statistics wstats;
@@ -1091,7 +1048,6 @@ struct ipw_priv {
 
         struct tasklet_struct irq_tasklet;
 
-
 #define IPW_2200BG  1
 #define IPW_2915ABG 2
         u8 adapter;
@@ -1114,7 +1070,6 @@ struct ipw_priv {
         u32 indirect_byte;
 };                              /*ipw_priv */
 
-
 /* debug macros */
 
 #ifdef CONFIG_IPW_DEBUG
@@ -1170,7 +1125,6 @@ do { if (ipw_debug_level & (level)) \
 #define IPW_DL_RF_KILL       (1<<17)
 #define IPW_DL_FW_ERRORS     (1<<18)
 
-
 #define IPW_DL_ORD           (1<<20)
 
 #define IPW_DL_FRAG          (1<<21)
@@ -1184,7 +1138,6 @@ do { if (ipw_debug_level & (level)) \
 
 #define IPW_DL_STATS         (1<<29)
 
-
 #define IPW_ERROR(f, a...) printk(KERN_ERR DRV_NAME ": " f, ## a)
 #define IPW_WARNING(f, a...) printk(KERN_WARNING DRV_NAME ": " f, ## a)
 #define IPW_DEBUG_INFO(f, a...)    IPW_DEBUG(IPW_DL_INFO, f, ## a)
@@ -1253,12 +1206,12 @@ do { if (ipw_debug_level & (level)) \
 /*
  * RESET Register Bit Indexes
  */
-#define CBD_RESET_REG_PRINCETON_RESET 0x00000001  /* Bit 0 (LSB) */
-#define CX2_RESET_REG_SW_RESET        0x00000080  /* Bit 7       */
-#define CX2_RESET_REG_MASTER_DISABLED 0x00000100  /* Bit 8       */
-#define CX2_RESET_REG_STOP_MASTER     0x00000200  /* Bit 9       */
-#define CX2_ARC_KESHET_CONFIG         0x08000000  /* Bit 27      */
-#define CX2_START_STANDBY             0x00000004  /* Bit 2       */
+#define CBD_RESET_REG_PRINCETON_RESET 0x00000001        /* Bit 0 (LSB) */
+#define CX2_RESET_REG_SW_RESET        0x00000080        /* Bit 7       */
+#define CX2_RESET_REG_MASTER_DISABLED 0x00000100        /* Bit 8       */
+#define CX2_RESET_REG_STOP_MASTER     0x00000200        /* Bit 9       */
+#define CX2_ARC_KESHET_CONFIG         0x08000000        /* Bit 27      */
+#define CX2_START_STANDBY             0x00000004        /* Bit 2       */
 
 #define CX2_CSR_CIS_UPPER_BOUND 0x00000200
 #define CX2_DOMAIN_0_END 0x1000
@@ -1289,14 +1242,12 @@ do { if (ipw_debug_level & (level)) \
 #define CB_SRC_SIZE_LONG  0x00200000
 #define CB_DEST_SIZE_LONG 0x00020000
 
-
 /* DMA DEFINES */
 
 #define DMA_CONTROL_SMALL_CB_CONST_VALUE 0x00540000
 #define DMA_CB_STOP_AND_ABORT            0x00000C00
 #define DMA_CB_START                     0x00000100
 
-
 #define CX2_SHARED_SRAM_SIZE               0x00030000
 #define CX2_SHARED_SRAM_DMA_CONTROL        0x00027000
 #define CB_MAX_LENGTH                      0x1FFF
@@ -1304,7 +1255,6 @@ do { if (ipw_debug_level & (level)) \
 #define CX2_HOST_EEPROM_DATA_SRAM_SIZE 0xA18
 #define CX2_EEPROM_IMAGE_SIZE          0x100
 
-
 /* DMA defs */
 #define CX2_DMA_I_CURRENT_CB  0x003000D0
 #define CX2_DMA_O_CURRENT_CB  0x003000D4
@@ -1356,7 +1306,6 @@ do { if (ipw_debug_level & (level)) \
 #define IPW_WHO_IS_AWAKE             (CX2_SHARED_LOWER_BOUND + 0xB14)
 #define IPW_DURING_ATIM_WINDOW       (CX2_SHARED_LOWER_BOUND + 0xB18)
 
-
 #define MSB                             1
 #define LSB                             0
 #define WORD_TO_BYTE(_word)             ((_word) * sizeof(u16))
@@ -1365,16 +1314,16 @@ do { if (ipw_debug_level & (level)) \
     ( WORD_TO_BYTE(_wordoffset) + (_byteoffset) )
 
 /* EEPROM access by BYTE */
-#define EEPROM_PME_CAPABILITY   (GET_EEPROM_ADDR(0x09,MSB))     /* 1 byte   */
-#define EEPROM_MAC_ADDRESS      (GET_EEPROM_ADDR(0x21,LSB))     /* 6 byte   */
-#define EEPROM_VERSION          (GET_EEPROM_ADDR(0x24,MSB))     /* 1 byte   */
-#define EEPROM_NIC_TYPE         (GET_EEPROM_ADDR(0x25,LSB))     /* 1 byte   */
-#define EEPROM_SKU_CAPABILITY   (GET_EEPROM_ADDR(0x25,MSB))     /* 1 byte   */
-#define EEPROM_COUNTRY_CODE     (GET_EEPROM_ADDR(0x26,LSB))     /* 3 bytes  */
-#define EEPROM_IBSS_CHANNELS_BG (GET_EEPROM_ADDR(0x28,LSB))     /* 2 bytes  */
-#define EEPROM_IBSS_CHANNELS_A  (GET_EEPROM_ADDR(0x29,MSB))     /* 5 bytes  */
-#define EEPROM_BSS_CHANNELS_BG  (GET_EEPROM_ADDR(0x2c,LSB))     /* 2 bytes  */
-#define EEPROM_HW_VERSION       (GET_EEPROM_ADDR(0x72,LSB))     /* 2 bytes  */
+#define EEPROM_PME_CAPABILITY   (GET_EEPROM_ADDR(0x09,MSB))     /* 1 byte   */
+#define EEPROM_MAC_ADDRESS      (GET_EEPROM_ADDR(0x21,LSB))     /* 6 byte   */
+#define EEPROM_VERSION          (GET_EEPROM_ADDR(0x24,MSB))     /* 1 byte   */
+#define EEPROM_NIC_TYPE         (GET_EEPROM_ADDR(0x25,LSB))     /* 1 byte   */
+#define EEPROM_SKU_CAPABILITY   (GET_EEPROM_ADDR(0x25,MSB))     /* 1 byte   */
+#define EEPROM_COUNTRY_CODE     (GET_EEPROM_ADDR(0x26,LSB))     /* 3 bytes  */
+#define EEPROM_IBSS_CHANNELS_BG (GET_EEPROM_ADDR(0x28,LSB))     /* 2 bytes  */
+#define EEPROM_IBSS_CHANNELS_A  (GET_EEPROM_ADDR(0x29,MSB))     /* 5 bytes  */
+#define EEPROM_BSS_CHANNELS_BG  (GET_EEPROM_ADDR(0x2c,LSB))     /* 2 bytes  */
+#define EEPROM_HW_VERSION       (GET_EEPROM_ADDR(0x72,LSB))     /* 2 bytes  */
 
 /* NIC type as found in the one byte EEPROM_NIC_TYPE  offset*/
 #define EEPROM_NIC_TYPE_STANDARD        0
@@ -1479,7 +1428,6 @@ enum {
 #define IPW_RATE_CAPABILITIES 1
 #define IPW_RATE_CONNECT      0
 
-
 /*
  * Rate values and masks
  */
@@ -1524,12 +1472,6 @@ enum {
         IPW_ORD_STAT_TX_DIR_DATA_B_11,
         /* Hole */
 
-
-
-
-
-
-
         IPW_ORD_STAT_TX_DIR_DATA_G_1 = IPW_ORD_TABLE_0_MASK + 19,
         IPW_ORD_STAT_TX_DIR_DATA_G_2,
         IPW_ORD_STAT_TX_DIR_DATA_G_5_5,
@@ -1549,12 +1491,6 @@ enum {
         IPW_ORD_STAT_TX_NON_DIR_DATA_B_11,
         /* Hole */
 
-
-
-
-
-
-
         IPW_ORD_STAT_TX_NON_DIR_DATA_G_1 = IPW_ORD_TABLE_0_MASK + 44,
         IPW_ORD_STAT_TX_NON_DIR_DATA_G_2,
         IPW_ORD_STAT_TX_NON_DIR_DATA_G_5_5,
@@ -1685,7 +1621,7 @@ struct host_cmd {
 #define CFG_BT_COEXISTENCE_WME_OVER_BT          0x08
 #define CFG_BT_COEXISTENCE_OOB                  0x10
 #define CFG_BT_COEXISTENCE_MAX                  0xFF
-#define CFG_BT_COEXISTENCE_DEF                  0x80 /* read Bt from EEPROM*/
+#define CFG_BT_COEXISTENCE_DEF                  0x80    /* read Bt from EEPROM */
 
 #define CFG_CTS_TO_ITSELF_ENABLED_MIN   0x0
 #define CFG_CTS_TO_ITSELF_ENABLED_MAX   0x1
@@ -1727,11 +1663,11 @@ static inline u32 frame_hdr_len(struct ieee80211_hdr *hdr)
         fc = le16_to_cpu(hdr->frame_ctl);
 
         /*
-         * Function     ToDS    FromDS
-         * IBSS         0       0
-         * To AP        1       0
-         * From AP      0       1
-         * WDS (bridge) 1       1
+         * Function     ToDS    FromDS
+         * IBSS         0       0
+         * To AP        1       0
+         * From AP      0       1
+         * WDS (bridge) 1       1
          *
          * Only WDS frames use Address4 among them. --YZ
          */
@@ -1741,4 +1677,4 @@ static inline u32 frame_hdr_len(struct ieee80211_hdr *hdr)
         return retval;
 }
 
-#endif /* __ipw2200_h__ */
+#endif                          /* __ipw2200_h__ */
diff --git a/drivers/net/wireless/netwave_cs.c b/drivers/net/wireless/netwave_cs.c
index 5f507c49907b..ca6c03c89926 100644
--- a/drivers/net/wireless/netwave_cs.c
+++ b/drivers/net/wireless/netwave_cs.c
@@ -471,12 +471,12 @@ static dev_link_t *netwave_attach(void)
     dev->get_stats  = &netwave_get_stats;
     dev->set_multicast_list = &set_multicast_list;
     /* wireless extensions */
-#ifdef WIRELESS_EXT
+#if WIRELESS_EXT <= 16
     dev->get_wireless_stats = &netwave_get_wireless_stats;
+#endif /* WIRELESS_EXT <= 16 */
 #if WIRELESS_EXT > 12
     dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
 #endif /* WIRELESS_EXT > 12 */
-#endif /* WIRELESS_EXT */
     dev->do_ioctl = &netwave_ioctl;
 
     dev->tx_timeout = &netwave_watchdog;
@@ -839,6 +839,9 @@ static const struct iw_handler_def	netwave_handler_def =
         .standard       = (iw_handler *) netwave_handler,
         .private        = (iw_handler *) netwave_private_handler,
         .private_args   = (struct iw_priv_args *) netwave_private_args,
+#if WIRELESS_EXT > 16
+        .get_wireless_stats = netwave_get_wireless_stats,
+#endif /* WIRELESS_EXT > 16 */
 };
 #endif /* WIRELESS_EXT > 12 */
 
diff --git a/drivers/net/wireless/prism54/isl_ioctl.c b/drivers/net/wireless/prism54/isl_ioctl.c
index 0f29a9c7bc2c..9a8790e3580c 100644
--- a/drivers/net/wireless/prism54/isl_ioctl.c
+++ b/drivers/net/wireless/prism54/isl_ioctl.c
@@ -2727,6 +2727,9 @@ const struct iw_handler_def prism54_handler_def = {
         .standard = (iw_handler *) prism54_handler,
         .private = (iw_handler *) prism54_private_handler,
         .private_args = (struct iw_priv_args *) prism54_private_args,
+#if WIRELESS_EXT > 16
+        .get_wireless_stats = prism54_get_wireless_stats,
+#endif /* WIRELESS_EXT > 16 */
 #if WIRELESS_EXT == 16
         .spy_offset = offsetof(islpci_private, spy_data),
 #endif /* WIRELESS_EXT == 16 */
diff --git a/drivers/net/wireless/prism54/islpci_dev.c b/drivers/net/wireless/prism54/islpci_dev.c
index efab07e9e24e..6f13d4a8e2d3 100644
--- a/drivers/net/wireless/prism54/islpci_dev.c
+++ b/drivers/net/wireless/prism54/islpci_dev.c
@@ -815,7 +815,6 @@ islpci_setup(struct pci_dev *pdev)
         ndev->open = &islpci_open;
         ndev->stop = &islpci_close;
         ndev->get_stats = &islpci_statistics;
-        ndev->get_wireless_stats = &prism54_get_wireless_stats;
         ndev->do_ioctl = &prism54_ioctl;
         ndev->wireless_handlers =
             (struct iw_handler_def *) &prism54_handler_def;
@@ -844,6 +843,8 @@ islpci_setup(struct pci_dev *pdev)
         /* Add pointers to enable iwspy support. */
         priv->wireless_data.spy_data = &priv->spy_data;
         ndev->wireless_data = &priv->wireless_data;
+#else  /* WIRELESS_EXT > 16 */
+        ndev->get_wireless_stats = &prism54_get_wireless_stats;
 #endif /* WIRELESS_EXT > 16 */
 
         /* save the start and end address of the PCI memory area */
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index 0e0ba614259a..e9c5ea0f5535 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -53,6 +53,7 @@
 #include <pcmcia/ds.h>
 #include <pcmcia/mem_op.h>
 
+#include <net/ieee80211.h>
 #include <linux/wireless.h>
 
 #include <asm/io.h>
@@ -64,7 +65,6 @@
 #define WIRELESS_SPY            /* Enable spying addresses */
 /* Definitions we need for spy */
 typedef struct iw_statistics    iw_stats;
-typedef struct iw_quality       iw_qual;
 typedef u_char  mac_addr[ETH_ALEN];     /* Hardware address */
 
 #include "rayctl.h"
@@ -101,7 +101,6 @@ static int ray_dev_close(struct net_device *dev);
 static int ray_dev_config(struct net_device *dev, struct ifmap *map);
 static struct net_device_stats *ray_get_stats(struct net_device *dev);
 static int ray_dev_init(struct net_device *dev);
-static int ray_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 
 static struct ethtool_ops netdev_ethtool_ops;
 
@@ -114,9 +113,8 @@ static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx,
 static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx, UCHAR msg_type,
                 unsigned char *data);
 static void untranslate(ray_dev_t *local, struct sk_buff *skb, int len);
-#if WIRELESS_EXT > 7    /* If wireless extension exist in the kernel */
 static iw_stats * ray_get_wireless_stats(struct net_device *    dev);
-#endif  /* WIRELESS_EXT > 7 */
+static const struct iw_handler_def      ray_handler_def;
 
 /***** Prototypes for raylink functions **************************************/
 static int asc_to_int(char a);
@@ -373,11 +371,12 @@ static dev_link_t *ray_attach(void)
     dev->hard_start_xmit = &ray_dev_start_xmit;
     dev->set_config = &ray_dev_config;
     dev->get_stats  = &ray_get_stats;
-    dev->do_ioctl = &ray_dev_ioctl;
     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
-#if WIRELESS_EXT > 7    /* If wireless extension exist in the kernel */
-    dev->get_wireless_stats = ray_get_wireless_stats;
-#endif
+    dev->wireless_handlers = &ray_handler_def;
+#ifdef WIRELESS_SPY
+    local->wireless_data.spy_data = &local->spy_data;
+    dev->wireless_data = &local->wireless_data;
+#endif  /* WIRELESS_SPY */
 
     dev->set_multicast_list = &set_multicast_list;
 
@@ -1201,436 +1200,420 @@ static struct ethtool_ops netdev_ethtool_ops = {
 
 /*====================================================================*/
 
-static int ray_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get protocol name
+ */
+static int ray_get_name(struct net_device *dev,
+                        struct iw_request_info *info,
+                        char *cwrq,
+                        char *extra)
 {
-    ray_dev_t *local = (ray_dev_t *)dev->priv;
-    dev_link_t *link = local->finder;
-    int err = 0;
-#if WIRELESS_EXT > 7
-    struct iwreq *wrq = (struct iwreq *) ifr;
-#endif  /* WIRELESS_EXT > 7 */
-#ifdef WIRELESS_SPY
-    struct sockaddr     address[IW_MAX_SPY];
-#endif  /* WIRELESS_SPY */
+        strcpy(cwrq, "IEEE 802.11-FH");
+        return 0;
+}
 
-    if (!(link->state & DEV_PRESENT)) {
-        DEBUG(2,"ray_dev_ioctl - device not present\n");
-        return -1;
-    }
-    DEBUG(2,"ray_cs IOCTL dev=%p, ifr=%p, cmd = 0x%x\n",dev,ifr,cmd);
-    /* Validate the command */
-    switch (cmd)
-    {
-#if WIRELESS_EXT > 7
-      /* --------------- WIRELESS EXTENSIONS --------------- */
-      /* Get name */
-    case SIOCGIWNAME:
-      strcpy(wrq->u.name, "IEEE 802.11-FH");
-      break;
-
-      /* Get frequency/channel */
-    case SIOCGIWFREQ:
-      wrq->u.freq.m = local->sparm.b5.a_hop_pattern;
-      wrq->u.freq.e = 0;
-      break;
-
-      /* Set frequency/channel */
-    case SIOCSIWFREQ:
-      /* Reject if card is already initialised */
-      if(local->card_status != CARD_AWAITING_PARAM)
-        {
-          err = -EBUSY;
-          break;
-        }
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : set frequency
+ */
+static int ray_set_freq(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct iw_freq *fwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+        int err = -EINPROGRESS;         /* Call commit handler */
 
-      /* Setting by channel number */
-      if ((wrq->u.freq.m > USA_HOP_MOD) || (wrq->u.freq.e > 0))
-        err = -EOPNOTSUPP;
-      else
-          local->sparm.b5.a_hop_pattern = wrq->u.freq.m;
-      break;
+        /* Reject if card is already initialised */
+        if(local->card_status != CARD_AWAITING_PARAM)
+                return -EBUSY;
 
-      /* Get current network name (ESSID) */
-    case SIOCGIWESSID:
-      if (wrq->u.data.pointer)
-        {
-          char essid[IW_ESSID_MAX_SIZE + 1];
-          /* Get the essid that was set */
-          memcpy(essid, local->sparm.b5.a_current_ess_id,
-                 IW_ESSID_MAX_SIZE);
-          essid[IW_ESSID_MAX_SIZE] = '\0';
-
-          /* Push it out ! */
-          wrq->u.data.length = strlen(essid) + 1;
-          wrq->u.data.flags = 1; /* active */
-          if (copy_to_user(wrq->u.data.pointer, essid, sizeof(essid)))
-                  err = -EFAULT;
-        }
-      break;
+        /* Setting by channel number */
+        if ((fwrq->m > USA_HOP_MOD) || (fwrq->e > 0))
+                err = -EOPNOTSUPP;
+        else
+                local->sparm.b5.a_hop_pattern = fwrq->m;
 
-      /* Set desired network name (ESSID) */
-    case SIOCSIWESSID:
-      /* Reject if card is already initialised */
-      if(local->card_status != CARD_AWAITING_PARAM)
-        {
-          err = -EBUSY;
-          break;
-        }
+        return err;
+}
+ 
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get frequency
+ */
+static int ray_get_freq(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct iw_freq *fwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
 
-        if (wrq->u.data.pointer)
-        {
-            char        card_essid[IW_ESSID_MAX_SIZE + 1];
-            
-            /* Check if we asked for `any' */
-            if(wrq->u.data.flags == 0)
-            {
+        fwrq->m = local->sparm.b5.a_hop_pattern;
+        fwrq->e = 0;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : set ESSID
+ */
+static int ray_set_essid(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_point *dwrq,
+                         char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+
+        /* Reject if card is already initialised */
+        if(local->card_status != CARD_AWAITING_PARAM)
+                return -EBUSY;
+
+        /* Check if we asked for `any' */
+        if(dwrq->flags == 0) {
                 /* Corey : can you do that ? */
-                err = -EOPNOTSUPP;
-            }
-            else
-            {
+                return -EOPNOTSUPP;
+        } else {
                 /* Check the size of the string */
-                if(wrq->u.data.length >
-                   IW_ESSID_MAX_SIZE + 1)
-                {
-                    err = -E2BIG;
-                    break;
-                }
-                if (copy_from_user(card_essid,
-                                   wrq->u.data.pointer,
-                                   wrq->u.data.length)) {
-                        err = -EFAULT;
-                        break;
+                if(dwrq->length > IW_ESSID_MAX_SIZE + 1) {
+                        return -E2BIG;
                 }
-                card_essid[IW_ESSID_MAX_SIZE] = '\0';
 
                 /* Set the ESSID in the card */
-                memcpy(local->sparm.b5.a_current_ess_id, card_essid,
-                       IW_ESSID_MAX_SIZE);
-            }
+                memset(local->sparm.b5.a_current_ess_id, 0, IW_ESSID_MAX_SIZE);
+                memcpy(local->sparm.b5.a_current_ess_id, extra, dwrq->length);
         }
-        break;
-
-      /* Get current Access Point (BSSID in our case) */
-    case SIOCGIWAP:
-      memcpy(wrq->u.ap_addr.sa_data, local->bss_id, ETH_ALEN);
-      wrq->u.ap_addr.sa_family = ARPHRD_ETHER;
-      break;
-
-      /* Get the current bit-rate */
-    case SIOCGIWRATE:
-      if(local->net_default_tx_rate == 3)
-        wrq->u.bitrate.value = 2000000;         /* Hum... */
-      else
-        wrq->u.bitrate.value = local->net_default_tx_rate * 500000;
-      wrq->u.bitrate.fixed = 0;         /* We are in auto mode */
-      break;
-
-      /* Set the desired bit-rate */
-    case SIOCSIWRATE:
-      /* Check if rate is in range */
-      if((wrq->u.bitrate.value != 1000000) &&
-         (wrq->u.bitrate.value != 2000000))
-        {
-          err = -EINVAL;
-          break;
-        }
-      /* Hack for 1.5 Mb/s instead of 2 Mb/s */
-      if((local->fw_ver == 0x55) &&             /* Please check */
-         (wrq->u.bitrate.value == 2000000))
-        local->net_default_tx_rate = 3;
-      else
-        local->net_default_tx_rate = wrq->u.bitrate.value/500000;
-      break;
-
-      /* Get the current RTS threshold */
-    case SIOCGIWRTS:
-      wrq->u.rts.value = (local->sparm.b5.a_rts_threshold[0] << 8)
-        + local->sparm.b5.a_rts_threshold[1];
-#if WIRELESS_EXT > 8
-      wrq->u.rts.disabled = (wrq->u.rts.value == 32767);
-#endif /* WIRELESS_EXT > 8 */
-      wrq->u.rts.fixed = 1;
-      break;
-
-      /* Set the desired RTS threshold */
-    case SIOCSIWRTS:
-    {
-        int rthr = wrq->u.rts.value;
 
-      /* Reject if card is already initialised */
-      if(local->card_status != CARD_AWAITING_PARAM)
-        {
-          err = -EBUSY;
-          break;
-        }
+        return -EINPROGRESS;            /* Call commit handler */
+}
 
-        /* if(wrq->u.rts.fixed == 0) we should complain */
-#if WIRELESS_EXT > 8
-        if(wrq->u.rts.disabled)
-            rthr = 32767;
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get ESSID
+ */
+static int ray_get_essid(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_point *dwrq,
+                         char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+
+        /* Get the essid that was set */
+        memcpy(extra, local->sparm.b5.a_current_ess_id, IW_ESSID_MAX_SIZE);
+        extra[IW_ESSID_MAX_SIZE] = '\0';
+
+        /* Push it out ! */
+        dwrq->length = strlen(extra) + 1;
+        dwrq->flags = 1; /* active */
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get AP address
+ */
+static int ray_get_wap(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct sockaddr *awrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+
+        memcpy(awrq->sa_data, local->bss_id, ETH_ALEN);
+        awrq->sa_family = ARPHRD_ETHER;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : set Bit-Rate
+ */
+static int ray_set_rate(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct iw_param *vwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+
+        /* Reject if card is already initialised */
+        if(local->card_status != CARD_AWAITING_PARAM)
+                return -EBUSY;
+
+        /* Check if rate is in range */
+        if((vwrq->value != 1000000) && (vwrq->value != 2000000))
+                return -EINVAL;
+
+        /* Hack for 1.5 Mb/s instead of 2 Mb/s */
+        if((local->fw_ver == 0x55) &&           /* Please check */
+           (vwrq->value == 2000000))
+                local->net_default_tx_rate = 3;
         else
-#endif /* WIRELESS_EXT > 8 */
-            if((rthr < 0) || (rthr > 2347)) /* What's the max packet size ??? */
-            {
-                err = -EINVAL;
-                break;
-            }
+                local->net_default_tx_rate = vwrq->value/500000;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get Bit-Rate
+ */
+static int ray_get_rate(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct iw_param *vwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+
+        if(local->net_default_tx_rate == 3)
+                vwrq->value = 2000000;          /* Hum... */
+        else
+                vwrq->value = local->net_default_tx_rate * 500000;
+        vwrq->fixed = 0;                /* We are in auto mode */
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : set RTS threshold
+ */
+static int ray_set_rts(struct net_device *dev,
+                       struct iw_request_info *info,
+                       struct iw_param *vwrq,
+                       char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+        int rthr = vwrq->value;
+
+        /* Reject if card is already initialised */
+        if(local->card_status != CARD_AWAITING_PARAM)
+                return -EBUSY;
+
+        /* if(wrq->u.rts.fixed == 0) we should complain */
+        if(vwrq->disabled)
+                rthr = 32767;
+        else {
+                if((rthr < 0) || (rthr > 2347)) /* What's the max packet size ??? */
+                        return -EINVAL;
+        }
         local->sparm.b5.a_rts_threshold[0] = (rthr >> 8) & 0xFF;
         local->sparm.b5.a_rts_threshold[1] = rthr & 0xFF;
-    }
-    break;
 
-      /* Get the current fragmentation threshold */
-    case SIOCGIWFRAG:
-      wrq->u.frag.value = (local->sparm.b5.a_frag_threshold[0] << 8)
-        + local->sparm.b5.a_frag_threshold[1];
-#if WIRELESS_EXT > 8
-      wrq->u.frag.disabled = (wrq->u.frag.value == 32767);
-#endif /* WIRELESS_EXT > 8 */
-      wrq->u.frag.fixed = 1;
-      break;
+        return -EINPROGRESS;            /* Call commit handler */
+}
 
-      /* Set the desired fragmentation threshold */
-    case SIOCSIWFRAG:
-    {
-        int fthr = wrq->u.frag.value;
 
-      /* Reject if card is already initialised */
-      if(local->card_status != CARD_AWAITING_PARAM)
-        {
-          err = -EBUSY;
-          break;
-        }
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get RTS threshold
+ */
+static int ray_get_rts(struct net_device *dev,
+                       struct iw_request_info *info,
+                       struct iw_param *vwrq,
+                       char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+
+        vwrq->value = (local->sparm.b5.a_rts_threshold[0] << 8)
+                + local->sparm.b5.a_rts_threshold[1];
+        vwrq->disabled = (vwrq->value == 32767);
+        vwrq->fixed = 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : set Fragmentation threshold
+ */
+static int ray_set_frag(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct iw_param *vwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+        int fthr = vwrq->value;
+
+        /* Reject if card is already initialised */
+        if(local->card_status != CARD_AWAITING_PARAM)
+                return -EBUSY;
 
         /* if(wrq->u.frag.fixed == 0) should complain */
-#if WIRELESS_EXT > 8
-        if(wrq->u.frag.disabled)
-            fthr = 32767;
-        else
-#endif /* WIRELESS_EXT > 8 */
-            if((fthr < 256) || (fthr > 2347)) /* To check out ! */
-            {
-                err = -EINVAL;
-                break;
-            }
+        if(vwrq->disabled)
+                fthr = 32767;
+        else {
+                if((fthr < 256) || (fthr > 2347)) /* To check out ! */
+                        return -EINVAL;
+        }
         local->sparm.b5.a_frag_threshold[0] = (fthr >> 8) & 0xFF;
         local->sparm.b5.a_frag_threshold[1] = fthr & 0xFF;
-    }
-    break;
 
-#endif  /* WIRELESS_EXT > 7 */
-#if WIRELESS_EXT > 8
+        return -EINPROGRESS;            /* Call commit handler */
+}
 
-      /* Get the current mode of operation */
-    case SIOCGIWMODE:
-      if(local->sparm.b5.a_network_type)
-        wrq->u.mode = IW_MODE_INFRA;
-      else
-        wrq->u.mode = IW_MODE_ADHOC;
-      break;
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get Fragmentation threshold
+ */
+static int ray_get_frag(struct net_device *dev,
+                        struct iw_request_info *info,
+                        struct iw_param *vwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
 
-      /* Set the current mode of operation */
-    case SIOCSIWMODE:
-    {
+        vwrq->value = (local->sparm.b5.a_frag_threshold[0] << 8)
+                + local->sparm.b5.a_frag_threshold[1];
+        vwrq->disabled = (vwrq->value == 32767);
+        vwrq->fixed = 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : set Mode of Operation
+ */
+static int ray_set_mode(struct net_device *dev,
+                        struct iw_request_info *info,
+                        __u32 *uwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
+        int err = -EINPROGRESS;         /* Call commit handler */
         char card_mode = 1;
-        
-      /* Reject if card is already initialised */
-      if(local->card_status != CARD_AWAITING_PARAM)
-        {
-          err = -EBUSY;
-          break;
-        }
 
-        switch (wrq->u.mode)
+        /* Reject if card is already initialised */
+        if(local->card_status != CARD_AWAITING_PARAM)
+                return -EBUSY;
+
+        switch (*uwrq)
         {
         case IW_MODE_ADHOC:
-            card_mode = 0;
-            // Fall through
+                card_mode = 0;
+                // Fall through
         case IW_MODE_INFRA:
-            local->sparm.b5.a_network_type = card_mode;
-            break;
+                local->sparm.b5.a_network_type = card_mode;
+                break;
         default:
-            err = -EINVAL;
+                err = -EINVAL;
         }
-    }
-    break;
 
-#endif /* WIRELESS_EXT > 8 */
-#if WIRELESS_EXT > 7
-      /* ------------------ IWSPY SUPPORT ------------------ */
-      /* Define the range (variations) of above parameters */
-    case SIOCGIWRANGE:
-      /* Basic checking... */
-      if(wrq->u.data.pointer != (caddr_t) 0)
-        {
-          struct iw_range       range;
-          memset((char *) &range, 0, sizeof(struct iw_range));
-
-          /* Set the length (very important for backward compatibility) */
-          wrq->u.data.length = sizeof(struct iw_range);
-
-#if WIRELESS_EXT > 10
-          /* Set the Wireless Extension versions */
-          range.we_version_compiled = WIRELESS_EXT;
-          range.we_version_source = 9;
-#endif /* WIRELESS_EXT > 10 */
-
-          /* Set information in the range struct */
-          range.throughput = 1.1 * 1000 * 1000; /* Put the right number here */
-          range.num_channels = hop_pattern_length[(int)country]; 
-          range.num_frequency = 0;
-          range.max_qual.qual = 0;
-          range.max_qual.level = 255;   /* What's the correct value ? */
-          range.max_qual.noise = 255;   /* Idem */
-          range.num_bitrates = 2;
-          range.bitrate[0] = 1000000;   /* 1 Mb/s */
-          range.bitrate[1] = 2000000;   /* 2 Mb/s */
-
-          /* Copy structure to the user buffer */
-          if(copy_to_user(wrq->u.data.pointer, &range,
-                          sizeof(struct iw_range)))
-            err = -EFAULT;
-        }
-      break;
+        return err;
+}
 
-#ifdef WIRELESS_SPY
-      /* Set addresses to spy */
-    case SIOCSIWSPY:
-      /* Check the number of addresses */
-      if(wrq->u.data.length > IW_MAX_SPY)
-        {
-          err = -E2BIG;
-          break;
-        }
-      local->spy_number = wrq->u.data.length;
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get Mode of Operation
+ */
+static int ray_get_mode(struct net_device *dev,
+                        struct iw_request_info *info,
+                        __u32 *uwrq,
+                        char *extra)
+{
+        ray_dev_t *local = (ray_dev_t *)dev->priv;
 
-      /* If there is some addresses to copy */
-      if(local->spy_number > 0)
-        {
-          int                   i;
-
-          /* Copy addresses to the driver */
-          if(copy_from_user(address, wrq->u.data.pointer,
-                            sizeof(struct sockaddr) * local->spy_number))
-            {
-              err = -EFAULT;
-              break;
-            }
-
-          /* Copy addresses to the lp structure */
-          for(i = 0; i < local->spy_number; i++)
-            memcpy(local->spy_address[i], address[i].sa_data, ETH_ALEN);
-
-          /* Reset structure... */
-          memset(local->spy_stat, 0x00, sizeof(iw_qual) * IW_MAX_SPY);
-
-#ifdef DEBUG_IOCTL_INFO
-          printk(KERN_DEBUG "SetSpy - Set of new addresses is :\n");
-          for(i = 0; i < local->spy_number; i++)
-            printk(KERN_DEBUG "%02X:%02X:%02X:%02X:%02X:%02X\n",
-                   local->spy_address[i][0],
-                   local->spy_address[i][1],
-                   local->spy_address[i][2],
-                   local->spy_address[i][3],
-                   local->spy_address[i][4],
-                   local->spy_address[i][5]);
-#endif  /* DEBUG_IOCTL_INFO */
-        }
-      break;
+        if(local->sparm.b5.a_network_type)
+                *uwrq = IW_MODE_INFRA;
+        else
+                *uwrq = IW_MODE_ADHOC;
 
-      /* Get the spy list and spy stats */
-    case SIOCGIWSPY:
-      /* Set the number of addresses */
-      wrq->u.data.length = local->spy_number;
+        return 0;
+}
 
-      /* If the user want to have the addresses back... */
-      if((local->spy_number > 0) && (wrq->u.data.pointer != (caddr_t) 0))
-        {
-          int                   i;
-
-          /* Copy addresses from the lp structure */
-          for(i = 0; i < local->spy_number; i++)
-            {
-              memcpy(address[i].sa_data, local->spy_address[i], ETH_ALEN);
-              address[i].sa_family = ARPHRD_ETHER;
-            }
-
-          /* Copy addresses to the user buffer */
-          if(copy_to_user(wrq->u.data.pointer, address,
-                       sizeof(struct sockaddr) * local->spy_number))
-            {
-              err = -EFAULT;
-              break;
-            }
-
-          /* Copy stats to the user buffer (just after) */
-          if(copy_to_user(wrq->u.data.pointer +
-                       (sizeof(struct sockaddr) * local->spy_number),
-                       local->spy_stat, sizeof(iw_qual) * local->spy_number))
-            {
-              err = -EFAULT;
-              break;
-            }
-
-          /* Reset updated flags */
-          for(i = 0; i < local->spy_number; i++)
-            local->spy_stat[i].updated = 0x0;
-        }       /* if(pointer != NULL) */
-
-      break;
-#endif  /* WIRELESS_SPY */
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Handler : get range info
+ */
+static int ray_get_range(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_point *dwrq,
+                         char *extra)
+{
+        struct iw_range *range = (struct iw_range *) extra;
+
+        memset((char *) range, 0, sizeof(struct iw_range));
+
+        /* Set the length (very important for backward compatibility) */
+        dwrq->length = sizeof(struct iw_range);
+
+        /* Set the Wireless Extension versions */
+        range->we_version_compiled = WIRELESS_EXT;
+        range->we_version_source = 9;
+
+        /* Set information in the range struct */
+        range->throughput = 1.1 * 1000 * 1000;  /* Put the right number here */
+        range->num_channels = hop_pattern_length[(int)country]; 
+        range->num_frequency = 0;
+        range->max_qual.qual = 0;
+        range->max_qual.level = 255;    /* What's the correct value ? */
+        range->max_qual.noise = 255;    /* Idem */
+        range->num_bitrates = 2;
+        range->bitrate[0] = 1000000;    /* 1 Mb/s */
+        range->bitrate[1] = 2000000;    /* 2 Mb/s */
+        return 0;
+}
 
-      /* ------------------ PRIVATE IOCTL ------------------ */
-#ifndef SIOCIWFIRSTPRIV
-#define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
-#endif /* SIOCIWFIRSTPRIV */
-#define SIOCSIPFRAMING  SIOCIWFIRSTPRIV         /* Set framing mode */
-#define SIOCGIPFRAMING  SIOCIWFIRSTPRIV + 1     /* Get framing mode */
-#define SIOCGIPCOUNTRY  SIOCIWFIRSTPRIV + 3     /* Get country code */
-    case SIOCSIPFRAMING:
-      if(!capable(CAP_NET_ADMIN))       /* For private IOCTLs, we need to check permissions */
-        {
-          err = -EPERM;
-          break;
-        }
-      translate = *(wrq->u.name);       /* Set framing mode */
-      break;
-    case SIOCGIPFRAMING:
-      *(wrq->u.name) = translate;
-      break;
-    case SIOCGIPCOUNTRY:
-      *(wrq->u.name) = country;
-      break;
-    case SIOCGIWPRIV:
-      /* Export our "private" intercace */
-      if(wrq->u.data.pointer != (caddr_t) 0)
-        {
-          struct iw_priv_args   priv[] =
-          {     /* cmd,         set_args,       get_args,       name */
-            { SIOCSIPFRAMING, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "set_framing" },
-            { SIOCGIPFRAMING, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "get_framing" },
-            { SIOCGIPCOUNTRY, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "get_country" },
-          };
-          /* Set the number of ioctl available */
-          wrq->u.data.length = 3;
-          /* Copy structure to the user buffer */
-          if(copy_to_user(wrq->u.data.pointer, (u_char *) priv,
-                       sizeof(priv)))
-            err = -EFAULT;
-        }
-      break;
-#endif  /* WIRELESS_EXT > 7 */
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Private Handler : set framing mode
+ */
+static int ray_set_framing(struct net_device *dev,
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu,
+                           char *extra)
+{
+        translate = *(extra);   /* Set framing mode */
 
+        return 0;
+}
 
-        default:
-            DEBUG(0,"ray_dev_ioctl cmd = 0x%x\n", cmd);
-            err = -EOPNOTSUPP;
-    }
-    return err;
-} /* end ray_dev_ioctl */
-/*===========================================================================*/
-#if WIRELESS_EXT > 7    /* If wireless extension exist in the kernel */
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Private Handler : get framing mode
+ */
+static int ray_get_framing(struct net_device *dev,
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu,
+                           char *extra)
+{
+        *(extra) = translate;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wireless Private Handler : get country
+ */
+static int ray_get_country(struct net_device *dev,
+                           struct iw_request_info *info,
+                           union iwreq_data *wrqu,
+                           char *extra)
+{
+        *(extra) = country;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Commit handler : called after a bunch of SET operations
+ */
+static int ray_commit(struct net_device *dev,
+                      struct iw_request_info *info,     /* NULL */
+                      void *zwrq,                       /* NULL */
+                      char *extra)                      /* NULL */
+{
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Stats handler : return Wireless Stats
+ */
 static iw_stats * ray_get_wireless_stats(struct net_device *    dev)
 {
   ray_dev_t *   local = (ray_dev_t *) dev->priv;
@@ -1642,13 +1625,13 @@ static iw_stats * ray_get_wireless_stats(struct net_device *	dev)
 
   local->wstats.status = local->card_status;
 #ifdef WIRELESS_SPY
-  if((local->spy_number > 0) && (local->sparm.b5.a_network_type == 0))
+  if((local->spy_data.spy_number > 0) && (local->sparm.b5.a_network_type == 0))
     {
       /* Get it from the first node in spy list */
-      local->wstats.qual.qual = local->spy_stat[0].qual;
-      local->wstats.qual.level = local->spy_stat[0].level;
-      local->wstats.qual.noise = local->spy_stat[0].noise;
-      local->wstats.qual.updated = local->spy_stat[0].updated;
+      local->wstats.qual.qual = local->spy_data.spy_stat[0].qual;
+      local->wstats.qual.level = local->spy_data.spy_stat[0].level;
+      local->wstats.qual.noise = local->spy_data.spy_stat[0].noise;
+      local->wstats.qual.updated = local->spy_data.spy_stat[0].updated;
     }
 #endif /* WIRELESS_SPY */
 
@@ -1659,7 +1642,65 @@ static iw_stats * ray_get_wireless_stats(struct net_device *	dev)
 
   return &local->wstats;
 } /* end ray_get_wireless_stats */
-#endif  /* WIRELESS_EXT > 7 */
+
+/*------------------------------------------------------------------*/
+/*
+ * Structures to export the Wireless Handlers
+ */
+
+static const iw_handler ray_handler[] = {
+        [SIOCSIWCOMMIT-SIOCIWFIRST] (iw_handler) ray_commit,
+        [SIOCGIWNAME  -SIOCIWFIRST] (iw_handler) ray_get_name,
+        [SIOCSIWFREQ  -SIOCIWFIRST] (iw_handler) ray_set_freq,
+        [SIOCGIWFREQ  -SIOCIWFIRST] (iw_handler) ray_get_freq,
+        [SIOCSIWMODE  -SIOCIWFIRST] (iw_handler) ray_set_mode,
+        [SIOCGIWMODE  -SIOCIWFIRST] (iw_handler) ray_get_mode,
+        [SIOCGIWRANGE -SIOCIWFIRST] (iw_handler) ray_get_range,
+#ifdef WIRELESS_SPY
+        [SIOCSIWSPY   -SIOCIWFIRST] (iw_handler) iw_handler_set_spy,
+        [SIOCGIWSPY   -SIOCIWFIRST] (iw_handler) iw_handler_get_spy,
+        [SIOCSIWTHRSPY-SIOCIWFIRST] (iw_handler) iw_handler_set_thrspy,
+        [SIOCGIWTHRSPY-SIOCIWFIRST] (iw_handler) iw_handler_get_thrspy,
+#endif  /* WIRELESS_SPY */
+        [SIOCGIWAP    -SIOCIWFIRST] (iw_handler) ray_get_wap,
+        [SIOCSIWESSID -SIOCIWFIRST] (iw_handler) ray_set_essid,
+        [SIOCGIWESSID -SIOCIWFIRST] (iw_handler) ray_get_essid,
+        [SIOCSIWRATE  -SIOCIWFIRST] (iw_handler) ray_set_rate,
+        [SIOCGIWRATE  -SIOCIWFIRST] (iw_handler) ray_get_rate,
+        [SIOCSIWRTS   -SIOCIWFIRST] (iw_handler) ray_set_rts,
+        [SIOCGIWRTS   -SIOCIWFIRST] (iw_handler) ray_get_rts,
+        [SIOCSIWFRAG  -SIOCIWFIRST] (iw_handler) ray_set_frag,
+        [SIOCGIWFRAG  -SIOCIWFIRST] (iw_handler) ray_get_frag,
+};
+
+#define SIOCSIPFRAMING  SIOCIWFIRSTPRIV         /* Set framing mode */
+#define SIOCGIPFRAMING  SIOCIWFIRSTPRIV + 1     /* Get framing mode */
+#define SIOCGIPCOUNTRY  SIOCIWFIRSTPRIV + 3     /* Get country code */
+
+static const iw_handler ray_private_handler[] = {
+        [0] (iw_handler) ray_set_framing,
+        [1] (iw_handler) ray_get_framing,
+        [3] (iw_handler) ray_get_country,
+};
+
+static const struct iw_priv_args        ray_private_args[] = {
+/* cmd,         set_args,       get_args,       name */
+{ SIOCSIPFRAMING, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "set_framing" },
+{ SIOCGIPFRAMING, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "get_framing" },
+{ SIOCGIPCOUNTRY, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "get_country" },
+};
+
+static const struct iw_handler_def      ray_handler_def =
+{
+        .num_standard   = sizeof(ray_handler)/sizeof(iw_handler),
+        .num_private    = sizeof(ray_private_handler)/sizeof(iw_handler),
+        .num_private_args = sizeof(ray_private_args)/sizeof(struct iw_priv_args),
+        .standard       = ray_handler,
+        .private        = ray_private_handler,
+        .private_args   = ray_private_args,
+        .get_wireless_stats = ray_get_wireless_stats,
+};
+
 /*===========================================================================*/
 static int ray_open(struct net_device *dev)
 {
@@ -2392,20 +2433,15 @@ static void rx_data(struct net_device *dev, struct rcs __iomem *prcs, unsigned i
         /*local->wstats.qual.noise = none ? */
         local->wstats.qual.updated = 0x2;
       }
-    /* Now, for the addresses in the spy list */
+    /* Now, update the spy stuff */
     {
-      int       i;
-      /* Look all addresses */
-      for(i = 0; i < local->spy_number; i++)
-        /* If match */
-        if(!memcmp(linksrcaddr, local->spy_address[i], ETH_ALEN))
-          {
-            /* Update statistics */
-            /*local->spy_stat[i].qual = none ? */
-            local->spy_stat[i].level = siglev;
-            /*local->spy_stat[i].noise = none ? */
-            local->spy_stat[i].updated = 0x2;
-          }
+        struct iw_quality wstats;
+        wstats.level = siglev;
+        /* wstats.noise = none ? */
+        /* wstats.qual = none ? */
+        wstats.updated = 0x2;
+        /* Update spy records */
+        wireless_spy_update(dev, linksrcaddr, &wstats);
     }
 #endif  /* WIRELESS_SPY */
 } /* end rx_data */
diff --git a/drivers/net/wireless/ray_cs.h b/drivers/net/wireless/ray_cs.h
index c77afa14fa86..42660fe64bfd 100644
--- a/drivers/net/wireless/ray_cs.h
+++ b/drivers/net/wireless/ray_cs.h
@@ -63,13 +63,10 @@ typedef struct ray_dev_t {
     UCHAR last_rsl;
     int beacon_rxed;
     struct beacon_rx last_bcn;
-#ifdef WIRELESS_EXT
     iw_stats    wstats;         /* Wireless specific stats */
-#endif
 #ifdef WIRELESS_SPY
-    int         spy_number;             /* Number of addresses to spy */
-    mac_addr    spy_address[IW_MAX_SPY + 1];    /* The addresses to spy */
-    iw_qual     spy_stat[IW_MAX_SPY + 1];       /* Statistics gathered */
+    struct iw_spy_data          spy_data;
+    struct iw_public_data       wireless_data;
 #endif  /* WIRELESS_SPY */
 
 } ray_dev_t;
diff --git a/drivers/net/wireless/wl3501.h b/drivers/net/wireless/wl3501.h
index b5719437e981..7fcbe589c3f2 100644
--- a/drivers/net/wireless/wl3501.h
+++ b/drivers/net/wireless/wl3501.h
@@ -609,6 +609,7 @@ struct wl3501_card {
         struct net_device_stats         stats;
         struct iw_statistics            wstats;
         struct iw_spy_data              spy_data;
+        struct iw_public_data           wireless_data;
         struct dev_node_t               node;
 };
 #endif
diff --git a/drivers/net/wireless/wl3501_cs.c b/drivers/net/wireless/wl3501_cs.c
index 7cc5edbf6ede..3f8c27f0871b 100644
--- a/drivers/net/wireless/wl3501_cs.c
+++ b/drivers/net/wireless/wl3501_cs.c
@@ -1944,7 +1944,7 @@ static const iw_handler	wl3501_handler[] = {
 static const struct iw_handler_def wl3501_handler_def = {
         .num_standard   = sizeof(wl3501_handler) / sizeof(iw_handler),
         .standard       = (iw_handler *)wl3501_handler,
-        .spy_offset     = offsetof(struct wl3501_card, spy_data),
+        .get_wireless_stats = wl3501_get_wireless_stats,
 };
 
 /**
@@ -1961,6 +1961,7 @@ static dev_link_t *wl3501_attach(void)
         client_reg_t client_reg;
         dev_link_t *link;
         struct net_device *dev;
+        struct wl3501_card *this;
         int ret;
 
         /* Initialize the dev_link_t structure */
@@ -1995,7 +1996,9 @@ static dev_link_t *wl3501_attach(void)
         dev->tx_timeout         = wl3501_tx_timeout;
         dev->watchdog_timeo     = 5 * HZ;
         dev->get_stats          = wl3501_get_stats;
-        dev->get_wireless_stats = wl3501_get_wireless_stats;
+        this = dev->priv;
+        this->wireless_data.spy_data = &this->spy_data;
+        dev->wireless_data      = &this->wireless_data;
         dev->wireless_handlers  = (struct iw_handler_def *)&wl3501_handler_def;
         SET_ETHTOOL_OPS(dev, &ops);
         netif_stop_queue(dev);
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 4598c6a9212d..97f723179f62 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -2739,6 +2739,7 @@ enum parport_pc_pci_cards {
         syba_2p_epp,
         syba_1p_ecp,
         titan_010l,
+        titan_1284p1,
         titan_1284p2,
         avlab_1p,
         avlab_2p,
@@ -2811,6 +2812,7 @@ static struct parport_pc_pci {
         /* syba_2p_epp AP138B */        { 2, { { 0, 0x078 }, { 0, 0x178 }, } },
         /* syba_1p_ecp W83787 */        { 1, { { 0, 0x078 }, } },
         /* titan_010l */                { 1, { { 3, -1 }, } },
+        /* titan_1284p1 */              { 1, { { 0, 1 }, } },
         /* titan_1284p2 */              { 2, { { 0, 1 }, { 2, 3 }, } },
         /* avlab_1p             */      { 1, { { 0, 1}, } },
         /* avlab_2p             */      { 2, { { 0, 1}, { 2, 3 },} },
@@ -2884,6 +2886,7 @@ static struct pci_device_id parport_pc_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, syba_1p_ecp },
         { PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_010L,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, titan_010l },
+        { 0x9710, 0x9805, 0x1000, 0x0010, 0, 0, titan_1284p1 },
         { 0x9710, 0x9815, 0x1000, 0x0020, 0, 0, titan_1284p2 },
         /* PCI_VENDOR_ID_AVLAB/Intek21 has another bunch of cards ...*/
         { 0x14db, 0x2120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, avlab_1p}, /* AFAVLAB_TK9902 */
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 2b85aa39f954..532f73bb2224 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -91,6 +91,7 @@ static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
 {
         struct msi_desc *entry;
         struct msg_address address;
+        unsigned int irq = vector;
 
         entry = (struct msi_desc *)msi_desc[vector];
         if (!entry || !entry->dev)
@@ -112,6 +113,7 @@ static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
                 entry->msi_attrib.current_cpu = cpu_mask_to_apicid(cpu_mask);
                 pci_write_config_dword(entry->dev, msi_lower_address_reg(pos),
                         address.lo_address.value);
+                set_native_irq_info(irq, cpu_mask);
                 break;
         }
         case PCI_CAP_ID_MSIX:
@@ -125,22 +127,13 @@ static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
                         MSI_TARGET_CPU_SHIFT);
                 entry->msi_attrib.current_cpu = cpu_mask_to_apicid(cpu_mask);
                 writel(address.lo_address.value, entry->mask_base + offset);
+                set_native_irq_info(irq, cpu_mask);
                 break;
         }
         default:
                 break;
         }
 }
-
-#ifdef CONFIG_IRQBALANCE
-static inline void move_msi(int vector)
-{
-        if (!cpus_empty(pending_irq_balance_cpumask[vector])) {
-                set_msi_affinity(vector, pending_irq_balance_cpumask[vector]);
-                cpus_clear(pending_irq_balance_cpumask[vector]);
-        }
-}
-#endif /* CONFIG_IRQBALANCE */
 #endif /* CONFIG_SMP */
 
 static void mask_MSI_irq(unsigned int vector)
@@ -191,13 +184,13 @@ static void shutdown_msi_irq(unsigned int vector)
 
 static void end_msi_irq_wo_maskbit(unsigned int vector)
 {
-        move_msi(vector);
+        move_native_irq(vector);
         ack_APIC_irq();
 }
 
 static void end_msi_irq_w_maskbit(unsigned int vector)
 {
-        move_msi(vector);
+        move_native_irq(vector);
         unmask_MSI_irq(vector);
         ack_APIC_irq();
 }
diff --git a/drivers/pci/msi.h b/drivers/pci/msi.h
index 390f1851c0f1..402136a5c9e4 100644
--- a/drivers/pci/msi.h
+++ b/drivers/pci/msi.h
@@ -19,7 +19,6 @@
 #define NR_HP_RESERVED_VECTORS  20
 
 extern int vector_irq[NR_VECTORS];
-extern cpumask_t pending_irq_balance_cpumask[NR_IRQS];
 extern void (*interrupt[NR_IRQS])(void);
 extern int pci_vector_resources(int last, int nr_released);
 
@@ -29,10 +28,6 @@ extern int pci_vector_resources(int last, int nr_released);
 #define set_msi_irq_affinity    NULL
 #endif
 
-#ifndef CONFIG_IRQBALANCE
-static inline void move_msi(int vector) {}
-#endif
-
 /*
  * MSI-X Address Register
  */
diff --git a/drivers/pcmcia/topic.h b/drivers/pcmcia/topic.h
index be420bb29113..edccfa5bb400 100644
--- a/drivers/pcmcia/topic.h
+++ b/drivers/pcmcia/topic.h
@@ -101,6 +101,8 @@
 #define  TOPIC97_AVS_AUDIO_CONTROL      0x02
 #define  TOPIC97_AVS_VIDEO_CONTROL      0x01
 
+#define TOPIC_EXCA_IF_CONTROL           0x3e    /* 8 bit */
+#define TOPIC_EXCA_IFC_33V_ENA          0x01
 
 static void topic97_zoom_video(struct pcmcia_socket *sock, int onoff)
 {
@@ -137,4 +139,19 @@ static int topic97_override(struct yenta_socket *socket)
         return 0;
 }
 
+
+static int topic95_override(struct yenta_socket *socket)
+{
+        u8 fctrl;
+
+        /* enable 3.3V support for 16bit cards */
+        fctrl = exca_readb(socket, TOPIC_EXCA_IF_CONTROL);
+        exca_writeb(socket, TOPIC_EXCA_IF_CONTROL, fctrl | TOPIC_EXCA_IFC_33V_ENA);
+
+        /* tell yenta to use exca registers to power 16bit cards */
+        socket->flags |= YENTA_16BIT_POWER_EXCA | YENTA_16BIT_POWER_DF;
+
+        return 0;
+}
+
 #endif /* _LINUX_TOPIC_H */
diff --git a/drivers/pcmcia/yenta_socket.c b/drivers/pcmcia/yenta_socket.c
index 62fd705203fb..0347a29f297b 100644
--- a/drivers/pcmcia/yenta_socket.c
+++ b/drivers/pcmcia/yenta_socket.c
@@ -184,22 +184,52 @@ static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value)
         return 0;
 }
 
-static int yenta_Vcc_power(u32 control)
+static void yenta_get_power(struct yenta_socket *socket, socket_state_t *state)
 {
-        switch (control & CB_SC_VCC_MASK) {
-        case CB_SC_VCC_5V: return 50;
-        case CB_SC_VCC_3V: return 33;
-        default: return 0;
-        }
-}
+        if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) &&
+            (socket->flags & YENTA_16BIT_POWER_EXCA)) {
+                u8 reg, vcc, vpp;
+
+                reg = exca_readb(socket, I365_POWER);
+                vcc = reg & I365_VCC_MASK;
+                vpp = reg & I365_VPP1_MASK;
+                state->Vcc = state->Vpp = 0;
+
+                if (socket->flags & YENTA_16BIT_POWER_DF) {
+                        if (vcc == I365_VCC_3V)
+                                state->Vcc = 33;
+                        if (vcc == I365_VCC_5V)
+                                state->Vcc = 50;
+                        if (vpp == I365_VPP1_5V)
+                                state->Vpp = state->Vcc;
+                        if (vpp == I365_VPP1_12V)
+                                state->Vpp = 120;
+                } else {
+                        if (reg & I365_VCC_5V) {
+                                state->Vcc = 50;
+                                if (vpp == I365_VPP1_5V)
+                                        state->Vpp = 50;
+                                if (vpp == I365_VPP1_12V)
+                                        state->Vpp = 120;
+                        }
+                }
+        } else {
+                u32 control;
 
-static int yenta_Vpp_power(u32 control)
-{
-        switch (control & CB_SC_VPP_MASK) {
-        case CB_SC_VPP_12V: return 120;
-        case CB_SC_VPP_5V: return 50;
-        case CB_SC_VPP_3V: return 33;
-        default: return 0;
+                control = cb_readl(socket, CB_SOCKET_CONTROL);
+
+                switch (control & CB_SC_VCC_MASK) {
+                case CB_SC_VCC_5V: state->Vcc = 50; break;
+                case CB_SC_VCC_3V: state->Vcc = 33; break;
+                default: state->Vcc = 0;
+                }
+
+                switch (control & CB_SC_VPP_MASK) {
+                case CB_SC_VPP_12V: state->Vpp = 120; break;
+                case CB_SC_VPP_5V: state->Vpp = 50; break;
+                case CB_SC_VPP_3V: state->Vpp = 33; break;
+                default: state->Vpp = 0;
+                }
         }
 }
 
@@ -211,8 +241,7 @@ static int yenta_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
 
         control = cb_readl(socket, CB_SOCKET_CONTROL);
 
-        state->Vcc = yenta_Vcc_power(control);
-        state->Vpp = yenta_Vpp_power(control);
+        yenta_get_power(socket, state);
         state->io_irq = socket->io_irq;
 
         if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) {
@@ -246,19 +275,54 @@ static int yenta_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
 
 static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state)
 {
-        u32 reg = 0;    /* CB_SC_STPCLK? */
-        switch (state->Vcc) {
-        case 33: reg = CB_SC_VCC_3V; break;
-        case 50: reg = CB_SC_VCC_5V; break;
-        default: reg = 0; break;
-        }
-        switch (state->Vpp) {
-        case 33:  reg |= CB_SC_VPP_3V; break;
-        case 50:  reg |= CB_SC_VPP_5V; break;
-        case 120: reg |= CB_SC_VPP_12V; break;
+        /* some birdges require to use the ExCA registers to power 16bit cards */
+        if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) &&
+            (socket->flags & YENTA_16BIT_POWER_EXCA)) {
+                u8 reg, old;
+                reg = old = exca_readb(socket, I365_POWER);
+                reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK);
+
+                /* i82365SL-DF style */
+                if (socket->flags & YENTA_16BIT_POWER_DF) {
+                        switch (state->Vcc) {
+                        case 33: reg |= I365_VCC_3V; break;
+                        case 50: reg |= I365_VCC_5V; break;
+                        default: reg = 0; break;
+                        }
+                        switch (state->Vpp) {
+                        case 33:
+                        case 50: reg |= I365_VPP1_5V; break;
+                        case 120: reg |= I365_VPP1_12V; break;
+                        }
+                } else {
+                        /* i82365SL-B style */
+                        switch (state->Vcc) {
+                        case 50: reg |= I365_VCC_5V; break;
+                        default: reg = 0; break;
+                        }
+                        switch (state->Vpp) {
+                        case 50: reg |= I365_VPP1_5V | I365_VPP2_5V; break;
+                        case 120: reg |= I365_VPP1_12V | I365_VPP2_12V; break;
+                        }
+                }
+
+                if (reg != old)
+                        exca_writeb(socket, I365_POWER, reg);
+        } else {
+                u32 reg = 0;    /* CB_SC_STPCLK? */
+                switch (state->Vcc) {
+                case 33: reg = CB_SC_VCC_3V; break;
+                case 50: reg = CB_SC_VCC_5V; break;
+                default: reg = 0; break;
+                }
+                switch (state->Vpp) {
+                case 33:  reg |= CB_SC_VPP_3V; break;
+                case 50:  reg |= CB_SC_VPP_5V; break;
+                case 120: reg |= CB_SC_VPP_12V; break;
+                }
+                if (reg != cb_readl(socket, CB_SOCKET_CONTROL))
+                        cb_writel(socket, CB_SOCKET_CONTROL, reg);
         }
-        if (reg != cb_readl(socket, CB_SOCKET_CONTROL))
-                cb_writel(socket, CB_SOCKET_CONTROL, reg);
 }
 
 static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
@@ -751,6 +815,7 @@ enum {
         CARDBUS_TYPE_TI12XX,
         CARDBUS_TYPE_TI1250,
         CARDBUS_TYPE_RICOH,
+        CARDBUS_TYPE_TOPIC95,
         CARDBUS_TYPE_TOPIC97,
         CARDBUS_TYPE_O2MICRO,
 };
@@ -789,6 +854,9 @@ static struct cardbus_type cardbus_type[] = {
                 .save_state     = ricoh_save_state,
                 .restore_state  = ricoh_restore_state,
         },
+        [CARDBUS_TYPE_TOPIC95]  = {
+                .override       = topic95_override,
+        },
         [CARDBUS_TYPE_TOPIC97]  = {
                 .override       = topic97_override,
         },
@@ -1196,6 +1264,7 @@ static struct pci_device_id yenta_table [] = {
         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH),
         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH),
 
+        CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95),
         CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97),
         CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97),
 
diff --git a/drivers/pcmcia/yenta_socket.h b/drivers/pcmcia/yenta_socket.h
index 4e637eef2076..4e75e9e258cd 100644
--- a/drivers/pcmcia/yenta_socket.h
+++ b/drivers/pcmcia/yenta_socket.h
@@ -95,6 +95,12 @@
  */
 #define CB_MEM_PAGE(map)        (0x40 + (map))
 
+
+/* control how 16bit cards are powered */
+#define YENTA_16BIT_POWER_EXCA  0x00000001
+#define YENTA_16BIT_POWER_DF    0x00000002
+
+
 struct yenta_socket;
 
 struct cardbus_type {
@@ -113,6 +119,8 @@ struct yenta_socket {
         struct pcmcia_socket socket;
         struct cardbus_type *type;
 
+        u32 flags;
+
         /* for PCI interrupt probing */
         unsigned int probe_status;
 
diff --git a/drivers/pnp/card.c b/drivers/pnp/card.c
index 6e5229e92fbc..e95ed67d4f05 100644
--- a/drivers/pnp/card.c
+++ b/drivers/pnp/card.c
@@ -8,13 +8,6 @@
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-
-#ifdef CONFIG_PNP_DEBUG
-        #define DEBUG
-#else
-        #undef DEBUG
-#endif
-
 #include <linux/pnp.h>
 #include "base.h"
 
diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c
index 1d037c2a82ac..33da25f3213f 100644
--- a/drivers/pnp/driver.c
+++ b/drivers/pnp/driver.c
@@ -11,13 +11,6 @@
 #include <linux/module.h>
 #include <linux/ctype.h>
 #include <linux/slab.h>
-
-#ifdef CONFIG_PNP_DEBUG
-        #define DEBUG
-#else
-        #undef DEBUG
-#endif
-
 #include <linux/pnp.h>
 #include "base.h"
 
diff --git a/drivers/pnp/isapnp/core.c b/drivers/pnp/isapnp/core.c
index 82c5edd5b9ee..beedd86800f4 100644
--- a/drivers/pnp/isapnp/core.c
+++ b/drivers/pnp/isapnp/core.c
@@ -142,17 +142,6 @@ static void isapnp_write_word(unsigned char idx, unsigned short val)
         isapnp_write_byte(idx+1, val);
 }
 
-static void *isapnp_alloc(long size)
-{
-        void *result;
-
-        result = kmalloc(size, GFP_KERNEL);
-        if (!result)
-                return NULL;
-        memset(result, 0, size);
-        return result;
-}
-
 static void isapnp_key(void)
 {
         unsigned char code = 0x6a, msb;
@@ -406,7 +395,7 @@ static void isapnp_parse_id(struct pnp_dev * dev, unsigned short vendor, unsigne
         struct pnp_id * id;
         if (!dev)
                 return;
-        id = isapnp_alloc(sizeof(struct pnp_id));
+        id = kcalloc(1, sizeof(struct pnp_id), GFP_KERNEL);
         if (!id)
                 return;
         sprintf(id->id, "%c%c%c%x%x%x%x",
@@ -430,7 +419,7 @@ static struct pnp_dev * __init isapnp_parse_device(struct pnp_card *card, int si
         struct pnp_dev *dev;
 
         isapnp_peek(tmp, size);
-        dev = isapnp_alloc(sizeof(struct pnp_dev));
+        dev = kcalloc(1, sizeof(struct pnp_dev), GFP_KERNEL);
         if (!dev)
                 return NULL;
         dev->number = number;
@@ -461,7 +450,7 @@ static void __init isapnp_parse_irq_resource(struct pnp_option *option,
         unsigned long bits;
 
         isapnp_peek(tmp, size);
-        irq = isapnp_alloc(sizeof(struct pnp_irq));
+        irq = kcalloc(1, sizeof(struct pnp_irq), GFP_KERNEL);
         if (!irq)
                 return;
         bits = (tmp[1] << 8) | tmp[0];
@@ -485,7 +474,7 @@ static void __init isapnp_parse_dma_resource(struct pnp_option *option,
         struct pnp_dma *dma;
 
         isapnp_peek(tmp, size);
-        dma = isapnp_alloc(sizeof(struct pnp_dma));
+        dma = kcalloc(1, sizeof(struct pnp_dma), GFP_KERNEL);
         if (!dma)
                 return;
         dma->map = tmp[0];
@@ -505,7 +494,7 @@ static void __init isapnp_parse_port_resource(struct pnp_option *option,
         struct pnp_port *port;
 
         isapnp_peek(tmp, size);
-        port = isapnp_alloc(sizeof(struct pnp_port));
+        port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
         if (!port)
                 return;
         port->min = (tmp[2] << 8) | tmp[1];
@@ -528,7 +517,7 @@ static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option,
         struct pnp_port *port;
 
         isapnp_peek(tmp, size);
-        port = isapnp_alloc(sizeof(struct pnp_port));
+        port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
         if (!port)
                 return;
         port->min = port->max = (tmp[1] << 8) | tmp[0];
@@ -550,7 +539,7 @@ static void __init isapnp_parse_mem_resource(struct pnp_option *option,
         struct pnp_mem *mem;
 
         isapnp_peek(tmp, size);
-        mem = isapnp_alloc(sizeof(struct pnp_mem));
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = ((tmp[2] << 8) | tmp[1]) << 8;
@@ -573,7 +562,7 @@ static void __init isapnp_parse_mem32_resource(struct pnp_option *option,
         struct pnp_mem *mem;
 
         isapnp_peek(tmp, size);
-        mem = isapnp_alloc(sizeof(struct pnp_mem));
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
@@ -595,7 +584,7 @@ static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option,
         struct pnp_mem *mem;
 
         isapnp_peek(tmp, size);
-        mem = isapnp_alloc(sizeof(struct pnp_mem));
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = mem->max = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
@@ -838,7 +827,7 @@ static unsigned char __init isapnp_checksum(unsigned char *data)
 
 static void isapnp_parse_card_id(struct pnp_card * card, unsigned short vendor, unsigned short device)
 {
-        struct pnp_id * id = isapnp_alloc(sizeof(struct pnp_id));
+        struct pnp_id * id = kcalloc(1, sizeof(struct pnp_id), GFP_KERNEL);
         if (!id)
                 return;
         sprintf(id->id, "%c%c%c%x%x%x%x",
@@ -874,7 +863,7 @@ static int __init isapnp_build_device_list(void)
                         header[4], header[5], header[6], header[7], header[8]);
                 printk(KERN_DEBUG "checksum = 0x%x\n", checksum);
 #endif
-                if ((card = isapnp_alloc(sizeof(struct pnp_card))) == NULL)
+                if ((card = kcalloc(1, sizeof(struct pnp_card), GFP_KERNEL)) == NULL)
                         continue;
 
                 card->number = csn;
diff --git a/drivers/pnp/manager.c b/drivers/pnp/manager.c
index 6c510c19ad7d..94442ffd4aed 100644
--- a/drivers/pnp/manager.c
+++ b/drivers/pnp/manager.c
@@ -11,13 +11,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
-
-#ifdef CONFIG_PNP_DEBUG
-        #define DEBUG
-#else
-        #undef DEBUG
-#endif
-
 #include <linux/pnp.h>
 #include "base.h"
 
diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
index 8655dd2e5b83..1a8915e74160 100644
--- a/drivers/pnp/pnpacpi/core.c
+++ b/drivers/pnp/pnpacpi/core.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
  
+#include <linux/config.h>
 #include <linux/acpi.h>
 #include <linux/pnp.h>
 #include <acpi/acpi_bus.h>
@@ -41,14 +42,6 @@ static inline int is_exclusive_device(struct acpi_device *dev)
         return (!acpi_match_ids(dev, excluded_id_list));
 }
 
-void *pnpacpi_kmalloc(size_t size, int f)
-{
-        void *p = kmalloc(size, f);
-        if (p)
-                memset(p, 0, size);
-        return p;
-}
-
 /*
  * Compatible Device IDs
  */
@@ -143,7 +136,7 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
                 return 0;
 
         pnp_dbg("ACPI device : hid %s", acpi_device_hid(device));
-        dev =  pnpacpi_kmalloc(sizeof(struct pnp_dev), GFP_KERNEL);
+        dev =  kcalloc(1, sizeof(struct pnp_dev), GFP_KERNEL);
         if (!dev) {
                 pnp_err("Out of memory");
                 return -ENOMEM;
@@ -173,7 +166,7 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
         dev->number = num;
         
         /* set the initial values for the PnP device */
-        dev_id = pnpacpi_kmalloc(sizeof(struct pnp_id), GFP_KERNEL);
+        dev_id = kcalloc(1, sizeof(struct pnp_id), GFP_KERNEL);
         if (!dev_id)
                 goto err;
         pnpidacpi_to_pnpid(acpi_device_hid(device), dev_id->id);
@@ -205,8 +198,7 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
                 for (i = 0; i < cid_list->count; i++) {
                         if (!ispnpidacpi(cid_list->id[i].value))
                                 continue;
-                        dev_id = pnpacpi_kmalloc(sizeof(struct pnp_id), 
-                                GFP_KERNEL);
+                        dev_id = kcalloc(1, sizeof(struct pnp_id), GFP_KERNEL);
                         if (!dev_id)
                                 continue;
 
diff --git a/drivers/pnp/pnpacpi/pnpacpi.h b/drivers/pnp/pnpacpi/pnpacpi.h
index 76f907e09ee6..f28e2ed66fa3 100644
--- a/drivers/pnp/pnpacpi/pnpacpi.h
+++ b/drivers/pnp/pnpacpi/pnpacpi.h
@@ -5,7 +5,6 @@
 #include <linux/acpi.h>
 #include <linux/pnp.h>
 
-void *pnpacpi_kmalloc(size_t size, int f);
 acpi_status pnpacpi_parse_allocated_resource(acpi_handle, struct pnp_resource_table*);
 acpi_status pnpacpi_parse_resource_option_data(acpi_handle, struct pnp_dev*);
 int pnpacpi_encode_resources(struct pnp_resource_table *, struct acpi_buffer *);
diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
index 75575f6c349c..675b76a42403 100644
--- a/drivers/pnp/pnpacpi/rsparser.c
+++ b/drivers/pnp/pnpacpi/rsparser.c
@@ -244,7 +244,7 @@ static void pnpacpi_parse_dma_option(struct pnp_option *option, struct acpi_reso
 
         if (p->number_of_channels == 0)
                 return;
-        dma = pnpacpi_kmalloc(sizeof(struct pnp_dma), GFP_KERNEL);
+        dma = kcalloc(1, sizeof(struct pnp_dma), GFP_KERNEL);
         if (!dma)
                 return;
 
@@ -300,7 +300,7 @@ static void pnpacpi_parse_irq_option(struct pnp_option *option,
         
         if (p->number_of_interrupts == 0)
                 return;
-        irq = pnpacpi_kmalloc(sizeof(struct pnp_irq), GFP_KERNEL);
+        irq = kcalloc(1, sizeof(struct pnp_irq), GFP_KERNEL);
         if (!irq)
                 return;
 
@@ -321,7 +321,7 @@ static void pnpacpi_parse_ext_irq_option(struct pnp_option *option,
 
         if (p->number_of_interrupts == 0)
                 return;
-        irq = pnpacpi_kmalloc(sizeof(struct pnp_irq), GFP_KERNEL);
+        irq = kcalloc(1, sizeof(struct pnp_irq), GFP_KERNEL);
         if (!irq)
                 return;
 
@@ -342,7 +342,7 @@ pnpacpi_parse_port_option(struct pnp_option *option,
 
         if (io->range_length == 0)
                 return;
-        port = pnpacpi_kmalloc(sizeof(struct pnp_port), GFP_KERNEL);
+        port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
         if (!port)
                 return;
         port->min = io->min_base_address;
@@ -363,7 +363,7 @@ pnpacpi_parse_fixed_port_option(struct pnp_option *option,
 
         if (io->range_length == 0)
                 return;
-        port = pnpacpi_kmalloc(sizeof(struct pnp_port), GFP_KERNEL);
+        port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
         if (!port)
                 return;
         port->min = port->max = io->base_address;
@@ -382,7 +382,7 @@ pnpacpi_parse_mem24_option(struct pnp_option *option,
 
         if (p->range_length == 0)
                 return;
-        mem = pnpacpi_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL);
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = p->min_base_address;
@@ -405,7 +405,7 @@ pnpacpi_parse_mem32_option(struct pnp_option *option,
 
         if (p->range_length == 0)
                 return;
-        mem = pnpacpi_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL);
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = p->min_base_address;
@@ -428,7 +428,7 @@ pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
 
         if (p->range_length == 0)
                 return;
-        mem = pnpacpi_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL);
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = mem->max = p->range_base_address;
@@ -612,7 +612,7 @@ int pnpacpi_build_resource_template(acpi_handle handle,
         if (!res_cnt)
                 return -EINVAL;
         buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
-        buffer->pointer = pnpacpi_kmalloc(buffer->length - 1, GFP_KERNEL);
+        buffer->pointer = kcalloc(1, buffer->length - 1, GFP_KERNEL);
         if (!buffer->pointer)
                 return -ENOMEM;
         pnp_dbg("Res cnt %d", res_cnt);
diff --git a/drivers/pnp/pnpbios/core.c b/drivers/pnp/pnpbios/core.c
index 778a324028f4..f49674f07949 100644
--- a/drivers/pnp/pnpbios/core.c
+++ b/drivers/pnp/pnpbios/core.c
@@ -86,16 +86,6 @@ int pnp_bios_present(void)
 
 struct pnp_dev_node_info node_info;
 
-void *pnpbios_kmalloc(size_t size, int f)
-{
-        void *p = kmalloc( size, f );
-        if ( p == NULL )
-                printk(KERN_ERR "PnPBIOS: kmalloc() failed\n");
-        else
-                memset(p, 0, size);
-        return p;
-}
-
 /*
  *
  * DOCKING FUNCTIONS
@@ -121,10 +111,10 @@ static int pnp_dock_event(int dock, struct pnp_docking_station_info *info)
         if (!current->fs->root) {
                 return -EAGAIN;
         }
-        if (!(envp = (char **) pnpbios_kmalloc (20 * sizeof (char *), GFP_KERNEL))) {
+        if (!(envp = (char **) kcalloc (20, sizeof (char *), GFP_KERNEL))) {
                 return -ENOMEM;
         }
-        if (!(buf = pnpbios_kmalloc (256, GFP_KERNEL))) {
+        if (!(buf = kcalloc (1, 256, GFP_KERNEL))) {
                 kfree (envp);
                 return -ENOMEM;
         }
@@ -231,7 +221,7 @@ static int pnpbios_get_resources(struct pnp_dev * dev, struct pnp_resource_table
         if(!pnpbios_is_dynamic(dev))
                 return -EPERM;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node)
                 return -1;
         if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) {
@@ -254,7 +244,7 @@ static int pnpbios_set_resources(struct pnp_dev * dev, struct pnp_resource_table
         if (!pnpbios_is_dynamic(dev))
                 return -EPERM;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node)
                 return -1;
         if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) {
@@ -305,7 +295,7 @@ static int pnpbios_disable_resources(struct pnp_dev *dev)
         if(dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev))
                 return -EPERM;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node)
                 return -ENOMEM;
 
@@ -347,7 +337,7 @@ static int insert_device(struct pnp_dev *dev, struct pnp_bios_node * node)
         }
 
         /* set the initial values for the PnP device */
-        dev_id = pnpbios_kmalloc(sizeof(struct pnp_id), GFP_KERNEL);
+        dev_id = kcalloc(1, sizeof(struct pnp_id), GFP_KERNEL);
         if (!dev_id)
                 return -1;
         pnpid32_to_pnpid(node->eisa_id,id);
@@ -385,7 +375,7 @@ static void __init build_devlist(void)
         struct pnp_bios_node *node;
         struct pnp_dev *dev;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node)
                 return;
 
@@ -402,7 +392,7 @@ static void __init build_devlist(void)
                                 break;
                 }
                 nodes_got++;
-                dev =  pnpbios_kmalloc(sizeof (struct pnp_dev), GFP_KERNEL);
+                dev =  kcalloc(1, sizeof (struct pnp_dev), GFP_KERNEL);
                 if (!dev)
                         break;
                 if(insert_device(dev,node)<0)
diff --git a/drivers/pnp/pnpbios/pnpbios.h b/drivers/pnp/pnpbios/pnpbios.h
index 01896e705ed4..d8cb2fd1f127 100644
--- a/drivers/pnp/pnpbios/pnpbios.h
+++ b/drivers/pnp/pnpbios/pnpbios.h
@@ -26,7 +26,6 @@ union pnp_bios_install_struct {
 
 extern int pnp_bios_present(void);
 extern int  pnpbios_dont_use_current_config;
-extern void *pnpbios_kmalloc(size_t size, int f);
 
 extern int pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node * node);
 extern int pnpbios_read_resources_from_node(struct pnp_resource_table *res, struct pnp_bios_node * node);
diff --git a/drivers/pnp/pnpbios/proc.c b/drivers/pnp/pnpbios/proc.c
index 6bb8e1973fd4..5a3dfc97f5e9 100644
--- a/drivers/pnp/pnpbios/proc.c
+++ b/drivers/pnp/pnpbios/proc.c
@@ -87,7 +87,7 @@ static int proc_read_escd(char *buf, char **start, off_t pos,
                 return -EFBIG;
         }
 
-        tmpbuf = pnpbios_kmalloc(escd.escd_size, GFP_KERNEL);
+        tmpbuf = kcalloc(1, escd.escd_size, GFP_KERNEL);
         if (!tmpbuf) return -ENOMEM;
 
         if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) {
@@ -133,7 +133,7 @@ static int proc_read_devices(char *buf, char **start, off_t pos,
         if (pos >= 0xff)
                 return 0;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node) return -ENOMEM;
 
         for (nodenum=pos; nodenum<0xff; ) {
@@ -168,7 +168,7 @@ static int proc_read_node(char *buf, char **start, off_t pos,
         u8 nodenum = (long)data;
         int len;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node) return -ENOMEM;
         if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
                 kfree(node);
@@ -188,7 +188,7 @@ static int proc_write_node(struct file *file, const char __user *buf,
         u8 nodenum = (long)data;
         int ret = count;
 
-        node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL);
+        node = kcalloc(1, node_info.max_node_size, GFP_KERNEL);
         if (!node)
                 return -ENOMEM;
         if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
diff --git a/drivers/pnp/pnpbios/rsparser.c b/drivers/pnp/pnpbios/rsparser.c
index e305bb132c24..b0ca65b68645 100644
--- a/drivers/pnp/pnpbios/rsparser.c
+++ b/drivers/pnp/pnpbios/rsparser.c
@@ -247,7 +247,7 @@ static void
 pnpbios_parse_mem_option(unsigned char *p, int size, struct pnp_option *option)
 {
         struct pnp_mem * mem;
-        mem = pnpbios_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL);
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = ((p[5] << 8) | p[4]) << 8;
@@ -263,7 +263,7 @@ static void
 pnpbios_parse_mem32_option(unsigned char *p, int size, struct pnp_option *option)
 {
         struct pnp_mem * mem;
-        mem = pnpbios_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL);
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
@@ -279,7 +279,7 @@ static void
 pnpbios_parse_fixed_mem32_option(unsigned char *p, int size, struct pnp_option *option)
 {
         struct pnp_mem * mem;
-        mem = pnpbios_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL);
+        mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
         if (!mem)
                 return;
         mem->min = mem->max = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
@@ -296,7 +296,7 @@ pnpbios_parse_irq_option(unsigned char *p, int size, struct pnp_option *option)
         struct pnp_irq * irq;
         unsigned long bits;
 
-        irq = pnpbios_kmalloc(sizeof(struct pnp_irq), GFP_KERNEL);
+        irq = kcalloc(1, sizeof(struct pnp_irq), GFP_KERNEL);
         if (!irq)
                 return;
         bits = (p[2] << 8) | p[1];
@@ -313,7 +313,7 @@ static void
 pnpbios_parse_dma_option(unsigned char *p, int size, struct pnp_option *option)
 {
         struct pnp_dma * dma;
-        dma = pnpbios_kmalloc(sizeof(struct pnp_dma), GFP_KERNEL);
+        dma = kcalloc(1, sizeof(struct pnp_dma), GFP_KERNEL);
         if (!dma)
                 return;
         dma->map = p[1];
@@ -326,7 +326,7 @@ static void
 pnpbios_parse_port_option(unsigned char *p, int size, struct pnp_option *option)
 {
         struct pnp_port * port;
-        port = pnpbios_kmalloc(sizeof(struct pnp_port), GFP_KERNEL);
+        port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
         if (!port)
                 return;
         port->min = (p[3] << 8) | p[2];
@@ -342,7 +342,7 @@ static void
 pnpbios_parse_fixed_port_option(unsigned char *p, int size, struct pnp_option *option)
 {
         struct pnp_port * port;
-        port = pnpbios_kmalloc(sizeof(struct pnp_port), GFP_KERNEL);
+        port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
         if (!port)
                 return;
         port->min = port->max = (p[2] << 8) | p[1];
@@ -530,7 +530,7 @@ pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_de
                 case SMALL_TAG_COMPATDEVID: /* compatible ID */
                         if (len != 4)
                                 goto len_err;
-                        dev_id =  pnpbios_kmalloc(sizeof (struct pnp_id), GFP_KERNEL);
+                        dev_id =  kcalloc(1, sizeof (struct pnp_id), GFP_KERNEL);
                         if (!dev_id)
                                 return NULL;
                         memset(dev_id, 0, sizeof(struct pnp_id));
diff --git a/drivers/pnp/quirks.c b/drivers/pnp/quirks.c
index 596a02d7e03d..8936b0cb2ec3 100644
--- a/drivers/pnp/quirks.c
+++ b/drivers/pnp/quirks.c
@@ -16,13 +16,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/slab.h>
-
-#ifdef CONFIG_PNP_DEBUG
-        #define DEBUG
-#else
-        #undef DEBUG
-#endif
-
 #include <linux/pnp.h>
 #include "base.h"
 
diff --git a/drivers/pnp/support.c b/drivers/pnp/support.c
index b952aec49189..61fe998944bd 100644
--- a/drivers/pnp/support.c
+++ b/drivers/pnp/support.c
@@ -8,13 +8,6 @@
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/ctype.h>
-
-#ifdef CONFIG_PNP_DEBUG
-        #define DEBUG
-#else
-        #undef DEBUG
-#endif
-
 #include <linux/pnp.h>
 #include "base.h"
 
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index 24c0af49c25c..3092473991a7 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -2,9 +2,9 @@
  *  drivers/s390/net/claw.c
  *    ESCON CLAW network driver
  *
- *    $Revision: 1.35 $ $Date: 2005/03/24 12:25:38 $
+ *    $Revision: 1.38 $ $Date: 2005/08/29 09:47:04 $
  *
- *  Linux fo zSeries version
+ *  Linux for zSeries version
  *    Copyright (C) 2002,2005 IBM Corporation
  *  Author(s) Original code written by:
  *              Kazuo Iimura (iimura@jp.ibm.com)
@@ -431,12 +431,12 @@ claw_pack_skb(struct claw_privbk *privptr)
         if (!skb_queue_empty(&p_ch->collect_queue)) {
         /* some data */
                 held_skb = skb_dequeue(&p_ch->collect_queue);
-                if (p_env->packing != DO_PACKED)
-                        return held_skb;
                 if (held_skb)
-                        atomic_dec(&held_skb->users);
+                        dev_kfree_skb_any(held_skb);
                 else
                         return NULL;
+                if (p_env->packing != DO_PACKED)
+                        return held_skb;
                 /* get a new SKB we will pack at least one */
                 new_skb = dev_alloc_skb(p_env->write_size);
                 if (new_skb == NULL) {
@@ -455,7 +455,7 @@ claw_pack_skb(struct claw_privbk *privptr)
                                 privptr->stats.tx_packets++;
                                 so_far += held_skb->len;
                                 pkt_cnt++;
-                                dev_kfree_skb_irq(held_skb);
+                                dev_kfree_skb_any(held_skb);
                                 held_skb = skb_dequeue(&p_ch->collect_queue);
                                 if (held_skb)
                                         atomic_dec(&held_skb->users);
@@ -1092,7 +1092,7 @@ claw_release(struct net_device *dev)
                 }
         }
         if (privptr->pk_skb != NULL) {
-                dev_kfree_skb(privptr->pk_skb);
+                dev_kfree_skb_any(privptr->pk_skb);
                 privptr->pk_skb = NULL;
         }
         if(privptr->buffs_alloc != 1) {
@@ -2016,7 +2016,7 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
         p_buf=(struct ccwbk*)privptr->p_end_ccw;
         dumpit((char *)p_buf, sizeof(struct endccw));
 #endif
-        dev_kfree_skb(skb);
+        dev_kfree_skb_any(skb);
         if (linkid==0) {
                 lock=LOCK_NO;
         }
@@ -4061,7 +4061,7 @@ claw_purge_skb_queue(struct sk_buff_head *q)
 
         while ((skb = skb_dequeue(q))) {
                 atomic_dec(&skb->users);
-                dev_kfree_skb_irq(skb);
+                dev_kfree_skb_any(skb);
         }
 }
 
@@ -4410,7 +4410,7 @@ claw_init(void)
 #else
                 "compiled into kernel "
 #endif
-                " $Revision: 1.35 $ $Date: 2005/03/24 12:25:38 $ \n");
+                " $Revision: 1.38 $ $Date: 2005/08/29 09:47:04 $ \n");
 
 
 #ifdef FUNCTRACE
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 787ad00a2b73..a261b9eea139 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -459,6 +459,15 @@ config SCSI_ATA_PIIX
 
           If unsure, say N.
 
+config SCSI_SATA_MV
+        tristate "Marvell SATA support"
+        depends on SCSI_SATA && PCI && EXPERIMENTAL
+        help
+          This option enables support for the Marvell Serial ATA family.
+          Currently supports 88SX[56]0[48][01] chips.
+
+          If unsure, say N.
+
 config SCSI_SATA_NV
         tristate "NVIDIA SATA support"
         depends on SCSI_SATA && PCI && EXPERIMENTAL
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 3746fb9fa2f5..c662b8c8cc6d 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -132,6 +132,7 @@ obj-$(CONFIG_SCSI_SATA_SIS)	+= libata.o sata_sis.o
 obj-$(CONFIG_SCSI_SATA_SX4)     += libata.o sata_sx4.o
 obj-$(CONFIG_SCSI_SATA_NV)      += libata.o sata_nv.o
 obj-$(CONFIG_SCSI_SATA_ULI)     += libata.o sata_uli.o
+obj-$(CONFIG_SCSI_SATA_MV)      += libata.o sata_mv.o
 
 obj-$(CONFIG_ARM)               += arm/
 
diff --git a/drivers/scsi/NCR5380.c b/drivers/scsi/NCR5380.c
index f8ec6fe7d858..d40ba0bd68a3 100644
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
@@ -88,6 +88,13 @@
  */
 #include <scsi/scsi_dbg.h>
 
+#ifndef NDEBUG
+#define NDEBUG 0
+#endif
+#ifndef NDEBUG
+#define NDEBUG_ABORT 0
+#endif
+
 #if (NDEBUG & NDEBUG_LISTS)
 #define LIST(x,y) {printk("LINE:%d   Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); if ((x)==(y)) udelay(5); }
 #define REMOVE(w,x,y,z) {printk("LINE:%d   Removing: %p->%p  %p->%p \n", __LINE__, (void*)(w), (void*)(x), (void*)(y), (void*)(z)); if ((x)==(y)) udelay(5); }
@@ -359,7 +366,7 @@ static struct {
         {PHASE_UNKNOWN, "UNKNOWN"}
 };
 
-#ifdef NDEBUG
+#if NDEBUG
 static struct {
         unsigned char mask;
         const char *name;
diff --git a/drivers/scsi/NCR53c406a.c b/drivers/scsi/NCR53c406a.c
index 79ae73b23680..e1f2246ee7cd 100644
--- a/drivers/scsi/NCR53c406a.c
+++ b/drivers/scsi/NCR53c406a.c
@@ -62,7 +62,7 @@
 
 #define SYNC_MODE 0             /* Synchronous transfer mode */
 
-#if DEBUG
+#ifdef DEBUG
 #undef NCR53C406A_DEBUG
 #define NCR53C406A_DEBUG 1
 #endif
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 31065261de8e..320df6cd3def 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -250,7 +250,7 @@ static struct ata_port_info ahci_port_info[] = {
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
                                   ATA_FLAG_PIO_DMA,
-                .pio_mask       = 0x03, /* pio3-4 */
+                .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
                 .port_ops       = &ahci_ops,
         },
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
new file mode 100644
index 000000000000..f97e3afa97d9
--- /dev/null
+++ b/drivers/scsi/sata_mv.c
@@ -0,0 +1,843 @@
+/*
+ * sata_mv.c - Marvell SATA support
+ *
+ * Copyright 2005: EMC Corporation, all rights reserved. 
+ *
+ * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/dma-mapping.h>
+#include "scsi.h"
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <asm/io.h>
+
+#define DRV_NAME        "sata_mv"
+#define DRV_VERSION     "0.12"
+
+enum {
+        /* BAR's are enumerated in terms of pci_resource_start() terms */
+        MV_PRIMARY_BAR          = 0,    /* offset 0x10: memory space */
+        MV_IO_BAR               = 2,    /* offset 0x18: IO space */
+        MV_MISC_BAR             = 3,    /* offset 0x1c: FLASH, NVRAM, SRAM */
+
+        MV_MAJOR_REG_AREA_SZ    = 0x10000,      /* 64KB */
+        MV_MINOR_REG_AREA_SZ    = 0x2000,       /* 8KB */
+
+        MV_PCI_REG_BASE         = 0,
+        MV_IRQ_COAL_REG_BASE    = 0x18000,      /* 6xxx part only */
+        MV_SATAHC0_REG_BASE     = 0x20000,
+
+        MV_PCI_REG_SZ           = MV_MAJOR_REG_AREA_SZ,
+        MV_SATAHC_REG_SZ        = MV_MAJOR_REG_AREA_SZ,
+        MV_SATAHC_ARBTR_REG_SZ  = MV_MINOR_REG_AREA_SZ,         /* arbiter */
+        MV_PORT_REG_SZ          = MV_MINOR_REG_AREA_SZ,
+
+        MV_Q_CT                 = 32,
+        MV_CRQB_SZ              = 32,
+        MV_CRPB_SZ              = 8,
+
+        MV_DMA_BOUNDARY         = 0xffffffffU,
+        SATAHC_MASK             = (~(MV_SATAHC_REG_SZ - 1)),
+
+        MV_PORTS_PER_HC         = 4,
+        /* == (port / MV_PORTS_PER_HC) to determine HC from 0-7 port */
+        MV_PORT_HC_SHIFT        = 2,
+        /* == (port % MV_PORTS_PER_HC) to determine port from 0-7 port */
+        MV_PORT_MASK            = 3,
+
+        /* Host Flags */
+        MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
+        MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
+        MV_FLAG_BDMA            = (1 << 28),  /* Basic DMA */
+
+        chip_504x               = 0,
+        chip_508x               = 1,
+        chip_604x               = 2,
+        chip_608x               = 3,
+
+        /* PCI interface registers */
+
+        PCI_MAIN_CMD_STS_OFS    = 0xd30,
+        STOP_PCI_MASTER         = (1 << 2),
+        PCI_MASTER_EMPTY        = (1 << 3),
+        GLOB_SFT_RST            = (1 << 4),
+
+        PCI_IRQ_CAUSE_OFS       = 0x1d58,
+        PCI_IRQ_MASK_OFS        = 0x1d5c,
+        PCI_UNMASK_ALL_IRQS     = 0x7fffff,     /* bits 22-0 */
+
+        HC_MAIN_IRQ_CAUSE_OFS   = 0x1d60,
+        HC_MAIN_IRQ_MASK_OFS    = 0x1d64,
+        PORT0_ERR               = (1 << 0),     /* shift by port # */
+        PORT0_DONE              = (1 << 1),     /* shift by port # */
+        HC0_IRQ_PEND            = 0x1ff,        /* bits 0-8 = HC0's ports */
+        HC_SHIFT                = 9,            /* bits 9-17 = HC1's ports */
+        PCI_ERR                 = (1 << 18),
+        TRAN_LO_DONE            = (1 << 19),    /* 6xxx: IRQ coalescing */
+        TRAN_HI_DONE            = (1 << 20),    /* 6xxx: IRQ coalescing */
+        PORTS_0_7_COAL_DONE     = (1 << 21),    /* 6xxx: IRQ coalescing */
+        GPIO_INT                = (1 << 22),
+        SELF_INT                = (1 << 23),
+        TWSI_INT                = (1 << 24),
+        HC_MAIN_RSVD            = (0x7f << 25), /* bits 31-25 */
+        HC_MAIN_MASKED_IRQS     = (TRAN_LO_DONE | TRAN_HI_DONE | 
+                                   PORTS_0_7_COAL_DONE | GPIO_INT | TWSI_INT |
+                                   HC_MAIN_RSVD),
+
+        /* SATAHC registers */
+        HC_CFG_OFS              = 0,
+
+        HC_IRQ_CAUSE_OFS        = 0x14,
+        CRBP_DMA_DONE           = (1 << 0),     /* shift by port # */
+        HC_IRQ_COAL             = (1 << 4),     /* IRQ coalescing */
+        DEV_IRQ                 = (1 << 8),     /* shift by port # */
+
+        /* Shadow block registers */
+        SHD_PIO_DATA_OFS        = 0x100,
+        SHD_FEA_ERR_OFS         = 0x104,
+        SHD_SECT_CNT_OFS        = 0x108,
+        SHD_LBA_L_OFS           = 0x10C,
+        SHD_LBA_M_OFS           = 0x110,
+        SHD_LBA_H_OFS           = 0x114,
+        SHD_DEV_HD_OFS          = 0x118,
+        SHD_CMD_STA_OFS         = 0x11C,
+        SHD_CTL_AST_OFS         = 0x120,
+
+        /* SATA registers */
+        SATA_STATUS_OFS         = 0x300,  /* ctrl, err regs follow status */
+        SATA_ACTIVE_OFS         = 0x350,
+
+        /* Port registers */
+        EDMA_CFG_OFS            = 0,
+
+        EDMA_ERR_IRQ_CAUSE_OFS  = 0x8,
+        EDMA_ERR_IRQ_MASK_OFS   = 0xc,
+        EDMA_ERR_D_PAR          = (1 << 0),
+        EDMA_ERR_PRD_PAR        = (1 << 1),
+        EDMA_ERR_DEV            = (1 << 2),
+        EDMA_ERR_DEV_DCON       = (1 << 3),
+        EDMA_ERR_DEV_CON        = (1 << 4),
+        EDMA_ERR_SERR           = (1 << 5),
+        EDMA_ERR_SELF_DIS       = (1 << 7),
+        EDMA_ERR_BIST_ASYNC     = (1 << 8),
+        EDMA_ERR_CRBQ_PAR       = (1 << 9),
+        EDMA_ERR_CRPB_PAR       = (1 << 10),
+        EDMA_ERR_INTRL_PAR      = (1 << 11),
+        EDMA_ERR_IORDY          = (1 << 12),
+        EDMA_ERR_LNK_CTRL_RX    = (0xf << 13),
+        EDMA_ERR_LNK_CTRL_RX_2  = (1 << 15),
+        EDMA_ERR_LNK_DATA_RX    = (0xf << 17),
+        EDMA_ERR_LNK_CTRL_TX    = (0x1f << 21),
+        EDMA_ERR_LNK_DATA_TX    = (0x1f << 26),
+        EDMA_ERR_TRANS_PROTO    = (1 << 31),
+        EDMA_ERR_FATAL          = (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR | 
+                                   EDMA_ERR_DEV_DCON | EDMA_ERR_CRBQ_PAR |
+                                   EDMA_ERR_CRPB_PAR | EDMA_ERR_INTRL_PAR |
+                                   EDMA_ERR_IORDY | EDMA_ERR_LNK_CTRL_RX_2 | 
+                                   EDMA_ERR_LNK_DATA_RX |
+                                   EDMA_ERR_LNK_DATA_TX | 
+                                   EDMA_ERR_TRANS_PROTO),
+
+        EDMA_CMD_OFS            = 0x28,
+        EDMA_EN                 = (1 << 0),
+        EDMA_DS                 = (1 << 1),
+        ATA_RST                 = (1 << 2),
+
+        /* BDMA is 6xxx part only */
+        BDMA_CMD_OFS            = 0x224,
+        BDMA_START              = (1 << 0),
+
+        MV_UNDEF                = 0,
+};
+
+struct mv_port_priv {
+
+};
+
+struct mv_host_priv {
+
+};
+
+static void mv_irq_clear(struct ata_port *ap);
+static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in);
+static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
+static void mv_phy_reset(struct ata_port *ap);
+static int mv_master_reset(void __iomem *mmio_base);
+static irqreturn_t mv_interrupt(int irq, void *dev_instance,
+                                struct pt_regs *regs);
+static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
+
+static Scsi_Host_Template mv_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .eh_strategy_handler    = ata_scsi_error,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = MV_UNDEF,
+        .max_sectors            = ATA_MAX_SECTORS,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = MV_UNDEF,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = MV_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .bios_param             = ata_std_bios_param,
+        .ordered_flush          = 1,
+};
+
+static struct ata_port_operations mv_ops = {
+        .port_disable           = ata_port_disable,
+
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .phy_reset              = mv_phy_reset,
+
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+
+        .eng_timeout            = ata_eng_timeout,
+
+        .irq_handler            = mv_interrupt,
+        .irq_clear              = mv_irq_clear,
+
+        .scr_read               = mv_scr_read,
+        .scr_write              = mv_scr_write,
+
+        .port_start             = ata_port_start,
+        .port_stop              = ata_port_stop,
+        .host_stop              = ata_host_stop,
+};
+
+static struct ata_port_info mv_port_info[] = {
+        {  /* chip_504x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+        {  /* chip_508x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO | 
+                                   MV_FLAG_DUAL_HC),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+        {  /* chip_604x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO | 
+                                   MV_FLAG_IRQ_COALESCE | MV_FLAG_BDMA),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+        {  /* chip_608x */
+                .sht            = &mv_sht,
+                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
+                                   MV_FLAG_IRQ_COALESCE | MV_FLAG_DUAL_HC |
+                                   MV_FLAG_BDMA),
+                .pio_mask       = 0x1f, /* pio4-0 */
+                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .port_ops       = &mv_ops,
+        },
+};
+
+static struct pci_device_id mv_pci_tbl[] = {
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5040), 0, 0, chip_504x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5041), 0, 0, chip_504x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5080), 0, 0, chip_508x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5081), 0, 0, chip_508x},
+
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6040), 0, 0, chip_604x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6041), 0, 0, chip_604x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6080), 0, 0, chip_608x},
+        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6081), 0, 0, chip_608x},
+        {}                      /* terminate list */
+};
+
+static struct pci_driver mv_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = mv_pci_tbl,
+        .probe                  = mv_init_one,
+        .remove                 = ata_pci_remove_one,
+};
+
+/*
+ * Functions
+ */
+
+static inline void writelfl(unsigned long data, void __iomem *addr)
+{
+        writel(data, addr);
+        (void) readl(addr);     /* flush to avoid PCI posted write */
+}
+
+static inline void __iomem *mv_port_addr_to_hc_base(void __iomem *port_mmio)
+{
+        return ((void __iomem *)((unsigned long)port_mmio & 
+                                 (unsigned long)SATAHC_MASK));
+}
+
+static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
+{
+        return (base + MV_SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
+}
+
+static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
+{
+        return (mv_hc_base(base, port >> MV_PORT_HC_SHIFT) +
+                MV_SATAHC_ARBTR_REG_SZ + 
+                ((port & MV_PORT_MASK) * MV_PORT_REG_SZ));
+}
+
+static inline void __iomem *mv_ap_base(struct ata_port *ap)
+{
+        return mv_port_base(ap->host_set->mmio_base, ap->port_no);
+}
+
+static inline int mv_get_hc_count(unsigned long flags)
+{
+        return ((flags & MV_FLAG_DUAL_HC) ? 2 : 1);
+}
+
+static inline int mv_is_edma_active(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        return (EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
+}
+
+static inline int mv_port_bdma_capable(struct ata_port *ap)
+{
+        return (ap->flags & MV_FLAG_BDMA);
+}
+
+static void mv_irq_clear(struct ata_port *ap)
+{
+}
+
+static unsigned int mv_scr_offset(unsigned int sc_reg_in)
+{
+        unsigned int ofs;
+
+        switch (sc_reg_in) {
+        case SCR_STATUS:
+        case SCR_CONTROL:
+        case SCR_ERROR:
+                ofs = SATA_STATUS_OFS + (sc_reg_in * sizeof(u32));
+                break;
+        case SCR_ACTIVE:
+                ofs = SATA_ACTIVE_OFS;   /* active is not with the others */
+                break;
+        default:
+                ofs = 0xffffffffU;
+                break;
+        }
+        return ofs;
+}
+
+static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
+{
+        unsigned int ofs = mv_scr_offset(sc_reg_in);
+
+        if (0xffffffffU != ofs) {
+                return readl(mv_ap_base(ap) + ofs);
+        } else {
+                return (u32) ofs;
+        }
+}
+
+static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
+{
+        unsigned int ofs = mv_scr_offset(sc_reg_in);
+
+        if (0xffffffffU != ofs) {
+                writelfl(val, mv_ap_base(ap) + ofs);
+        }
+}
+
+static int mv_master_reset(void __iomem *mmio_base)
+{
+        void __iomem *reg = mmio_base + PCI_MAIN_CMD_STS_OFS;
+        int i, rc = 0;
+        u32 t;
+
+        VPRINTK("ENTER\n");
+
+        /* Following procedure defined in PCI "main command and status
+         * register" table.
+         */
+        t = readl(reg);
+        writel(t | STOP_PCI_MASTER, reg);
+
+        for (i = 0; i < 100; i++) {
+                msleep(10);
+                t = readl(reg);
+                if (PCI_MASTER_EMPTY & t) {
+                        break;
+                }
+        }
+        if (!(PCI_MASTER_EMPTY & t)) {
+                printk(KERN_ERR DRV_NAME "PCI master won't flush\n");
+                rc = 1;         /* broken HW? */
+                goto done;
+        }
+
+        /* set reset */
+        i = 5;
+        do {
+                writel(t | GLOB_SFT_RST, reg);
+                t = readl(reg);
+                udelay(1);
+        } while (!(GLOB_SFT_RST & t) && (i-- > 0));
+
+        if (!(GLOB_SFT_RST & t)) {
+                printk(KERN_ERR DRV_NAME "can't set global reset\n");
+                rc = 1;         /* broken HW? */
+                goto done;
+        }
+
+        /* clear reset */
+        i = 5;
+        do {
+                writel(t & ~GLOB_SFT_RST, reg);
+                t = readl(reg);
+                udelay(1);
+        } while ((GLOB_SFT_RST & t) && (i-- > 0));
+
+        if (GLOB_SFT_RST & t) {
+                printk(KERN_ERR DRV_NAME "can't clear global reset\n");
+                rc = 1;         /* broken HW? */
+        }
+
+ done:
+        VPRINTK("EXIT, rc = %i\n", rc);
+        return rc;
+}
+
+static void mv_err_intr(struct ata_port *ap)
+{
+        void __iomem *port_mmio;
+        u32 edma_err_cause, serr = 0;
+
+        /* bug here b/c we got an err int on a port we don't know about,
+         * so there's no way to clear it
+         */
+        BUG_ON(NULL == ap);
+        port_mmio = mv_ap_base(ap);
+
+        edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
+
+        if (EDMA_ERR_SERR & edma_err_cause) {
+                serr = scr_read(ap, SCR_ERROR);
+                scr_write_flush(ap, SCR_ERROR, serr);
+        }
+        DPRINTK("port %u error; EDMA err cause: 0x%08x SERR: 0x%08x\n", 
+                ap->port_no, edma_err_cause, serr);
+
+        /* Clear EDMA now that SERR cleanup done */
+        writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
+
+        /* check for fatal here and recover if needed */
+        if (EDMA_ERR_FATAL & edma_err_cause) {
+                mv_phy_reset(ap);
+        }
+}
+
+/* Handle any outstanding interrupts in a single SATAHC 
+ */
+static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
+                         unsigned int hc)
+{
+        void __iomem *mmio = host_set->mmio_base;
+        void __iomem *hc_mmio = mv_hc_base(mmio, hc);
+        struct ata_port *ap;
+        struct ata_queued_cmd *qc;
+        u32 hc_irq_cause;
+        int shift, port, port0, hard_port;
+        u8 ata_status;
+
+        if (hc == 0) {
+                port0 = 0;
+        } else {
+                port0 = MV_PORTS_PER_HC;
+        }
+
+        /* we'll need the HC success int register in most cases */
+        hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
+        if (hc_irq_cause) {
+                writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
+        }
+
+        VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
+                hc,relevant,hc_irq_cause);
+
+        for (port = port0; port < port0 + MV_PORTS_PER_HC; port++) {
+                ap = host_set->ports[port];
+                hard_port = port & MV_PORT_MASK;        /* range 0-3 */
+                ata_status = 0xffU;
+
+                if (((CRBP_DMA_DONE | DEV_IRQ) << hard_port) & hc_irq_cause) {
+                        BUG_ON(NULL == ap);
+                        /* rcv'd new resp, basic DMA complete, or ATA IRQ */
+                        /* This is needed to clear the ATA INTRQ.
+                         * FIXME: don't read the status reg in EDMA mode!
+                         */
+                        ata_status = readb((void __iomem *)
+                                           ap->ioaddr.status_addr);
+                }
+
+                shift = port * 2;
+                if (port >= MV_PORTS_PER_HC) {
+                        shift++;        /* skip bit 8 in the HC Main IRQ reg */
+                }
+                if ((PORT0_ERR << shift) & relevant) {
+                        mv_err_intr(ap);
+                        /* FIXME: smart to OR in ATA_ERR? */
+                        ata_status = readb((void __iomem *)
+                                           ap->ioaddr.status_addr) | ATA_ERR;
+                }
+                
+                if (ap) {
+                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        if (NULL != qc) {
+                                VPRINTK("port %u IRQ found for qc, "
+                                        "ata_status 0x%x\n", port,ata_status);
+                                BUG_ON(0xffU == ata_status);
+                                /* mark qc status appropriately */
+                                ata_qc_complete(qc, ata_status);
+                        }
+                }
+        }
+        VPRINTK("EXIT\n");
+}
+
+static irqreturn_t mv_interrupt(int irq, void *dev_instance,
+                                struct pt_regs *regs)
+{
+        struct ata_host_set *host_set = dev_instance;
+        unsigned int hc, handled = 0, n_hcs;
+        void __iomem *mmio;
+        u32 irq_stat;
+
+        mmio = host_set->mmio_base;
+        irq_stat = readl(mmio + HC_MAIN_IRQ_CAUSE_OFS);
+        n_hcs = mv_get_hc_count(host_set->ports[0]->flags);
+
+        /* check the cases where we either have nothing pending or have read
+         * a bogus register value which can indicate HW removal or PCI fault
+         */
+        if (!irq_stat || (0xffffffffU == irq_stat)) {
+                return IRQ_NONE;
+        }
+
+        spin_lock(&host_set->lock);
+
+        for (hc = 0; hc < n_hcs; hc++) {
+                u32 relevant = irq_stat & (HC0_IRQ_PEND << (hc * HC_SHIFT));
+                if (relevant) {
+                        mv_host_intr(host_set, relevant, hc);
+                        handled = 1;
+                }
+        }
+        if (PCI_ERR & irq_stat) {
+                /* FIXME: these are all masked by default, but still need
+                 * to recover from them properly.
+                 */
+        }
+
+        spin_unlock(&host_set->lock);
+
+        return IRQ_RETVAL(handled);
+}
+
+static void mv_phy_reset(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        struct ata_taskfile tf;
+        struct ata_device *dev = &ap->device[0];
+        u32 edma = 0, bdma;
+
+        VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
+
+        edma = readl(port_mmio + EDMA_CMD_OFS);
+        if (EDMA_EN & edma) {
+                /* disable EDMA if active */
+                edma &= ~EDMA_EN;
+                writelfl(edma | EDMA_DS, port_mmio + EDMA_CMD_OFS);
+                udelay(1);
+        } else if (mv_port_bdma_capable(ap) &&
+                   (bdma = readl(port_mmio + BDMA_CMD_OFS)) & BDMA_START) {
+                /* disable BDMA if active */
+                writelfl(bdma & ~BDMA_START, port_mmio + BDMA_CMD_OFS);
+        }
+
+        writelfl(edma | ATA_RST, port_mmio + EDMA_CMD_OFS);
+        udelay(25);             /* allow reset propagation */
+
+        /* Spec never mentions clearing the bit.  Marvell's driver does
+         * clear the bit, however.
+         */
+        writelfl(edma & ~ATA_RST, port_mmio + EDMA_CMD_OFS);
+
+        VPRINTK("Done.  Now calling __sata_phy_reset()\n");
+
+        /* proceed to init communications via the scr_control reg */
+        __sata_phy_reset(ap);
+
+        if (ap->flags & ATA_FLAG_PORT_DISABLED) {
+                VPRINTK("Port disabled pre-sig.  Exiting.\n");
+                return;
+        }
+
+        tf.lbah = readb((void __iomem *) ap->ioaddr.lbah_addr);
+        tf.lbam = readb((void __iomem *) ap->ioaddr.lbam_addr);
+        tf.lbal = readb((void __iomem *) ap->ioaddr.lbal_addr);
+        tf.nsect = readb((void __iomem *) ap->ioaddr.nsect_addr);
+
+        dev->class = ata_dev_classify(&tf);
+        if (!ata_dev_present(dev)) {
+                VPRINTK("Port disabled post-sig: No device present.\n");
+                ata_port_disable(ap);
+        }
+        VPRINTK("EXIT\n");
+}
+
+static void mv_port_init(struct ata_ioports *port, unsigned long base)
+{
+        /* PIO related setup */
+        port->data_addr = base + SHD_PIO_DATA_OFS;
+        port->error_addr = port->feature_addr = base + SHD_FEA_ERR_OFS;
+        port->nsect_addr = base + SHD_SECT_CNT_OFS;
+        port->lbal_addr = base + SHD_LBA_L_OFS;
+        port->lbam_addr = base + SHD_LBA_M_OFS;
+        port->lbah_addr = base + SHD_LBA_H_OFS;
+        port->device_addr = base + SHD_DEV_HD_OFS;
+        port->status_addr = port->command_addr = base + SHD_CMD_STA_OFS;
+        port->altstatus_addr = port->ctl_addr = base + SHD_CTL_AST_OFS;
+        /* unused */
+        port->cmd_addr = port->bmdma_addr = port->scr_addr = 0;
+
+        /* unmask all EDMA error interrupts */
+        writel(~0, (void __iomem *)base + EDMA_ERR_IRQ_MASK_OFS);
+
+        VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n", 
+                readl((void __iomem *)base + EDMA_CFG_OFS),
+                readl((void __iomem *)base + EDMA_ERR_IRQ_CAUSE_OFS),
+                readl((void __iomem *)base + EDMA_ERR_IRQ_MASK_OFS));
+}
+
+static int mv_host_init(struct ata_probe_ent *probe_ent)
+{
+        int rc = 0, n_hc, port, hc;
+        void __iomem *mmio = probe_ent->mmio_base;
+        void __iomem *port_mmio;
+
+        if (mv_master_reset(probe_ent->mmio_base)) {
+                rc = 1;
+                goto done;
+        }
+
+        n_hc = mv_get_hc_count(probe_ent->host_flags);
+        probe_ent->n_ports = MV_PORTS_PER_HC * n_hc;
+
+        for (port = 0; port < probe_ent->n_ports; port++) {
+                port_mmio = mv_port_base(mmio, port);
+                mv_port_init(&probe_ent->port[port], (unsigned long)port_mmio);
+        }
+
+        for (hc = 0; hc < n_hc; hc++) {
+                VPRINTK("HC%i: HC config=0x%08x HC IRQ cause=0x%08x\n", hc,
+                        readl(mv_hc_base(mmio, hc) + HC_CFG_OFS),
+                        readl(mv_hc_base(mmio, hc) + HC_IRQ_CAUSE_OFS));
+        }
+
+        writel(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
+        writel(PCI_UNMASK_ALL_IRQS, mmio + PCI_IRQ_MASK_OFS);
+
+        VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
+                "PCI int cause/mask=0x%08x/0x%08x\n", 
+                readl(mmio + HC_MAIN_IRQ_CAUSE_OFS),
+                readl(mmio + HC_MAIN_IRQ_MASK_OFS),
+                readl(mmio + PCI_IRQ_CAUSE_OFS),
+                readl(mmio + PCI_IRQ_MASK_OFS));
+
+ done:
+        return rc;
+}
+
+/* move to PCI layer, integrate w/ MSI stuff */
+static void pci_intx(struct pci_dev *pdev, int enable)
+{
+        u16 pci_command, new;
+
+        pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
+
+        if (enable)
+                new = pci_command & ~PCI_COMMAND_INTX_DISABLE;
+        else
+                new = pci_command | PCI_COMMAND_INTX_DISABLE;
+
+        if (new != pci_command)
+                pci_write_config_word(pdev, PCI_COMMAND, pci_command);
+}
+
+static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        static int printed_version = 0;
+        struct ata_probe_ent *probe_ent = NULL;
+        struct mv_host_priv *hpriv;
+        unsigned int board_idx = (unsigned int)ent->driver_data;
+        void __iomem *mmio_base;
+        int pci_dev_busy = 0;
+        int rc;
+
+        if (!printed_version++) {
+                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+        }
+
+        VPRINTK("ENTER for PCI Bus:Slot.Func=%u:%u.%u\n", pdev->bus->number,
+                PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
+
+        rc = pci_enable_device(pdev);
+        if (rc) {
+                return rc;
+        }
+
+        rc = pci_request_regions(pdev, DRV_NAME);
+        if (rc) {
+                pci_dev_busy = 1;
+                goto err_out;
+        }
+
+        pci_intx(pdev, 1);
+
+        probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
+        if (probe_ent == NULL) {
+                rc = -ENOMEM;
+                goto err_out_regions;
+        }
+
+        memset(probe_ent, 0, sizeof(*probe_ent));
+        probe_ent->dev = pci_dev_to_dev(pdev);
+        INIT_LIST_HEAD(&probe_ent->node);
+
+        mmio_base = ioremap_nocache(pci_resource_start(pdev, MV_PRIMARY_BAR),
+                                    pci_resource_len(pdev, MV_PRIMARY_BAR));
+        if (mmio_base == NULL) {
+                rc = -ENOMEM;
+                goto err_out_free_ent;
+        }
+
+        hpriv = kmalloc(sizeof(*hpriv), GFP_KERNEL);
+        if (!hpriv) {
+                rc = -ENOMEM;
+                goto err_out_iounmap;
+        }
+        memset(hpriv, 0, sizeof(*hpriv));
+
+        probe_ent->sht = mv_port_info[board_idx].sht;
+        probe_ent->host_flags = mv_port_info[board_idx].host_flags;
+        probe_ent->pio_mask = mv_port_info[board_idx].pio_mask;
+        probe_ent->udma_mask = mv_port_info[board_idx].udma_mask;
+        probe_ent->port_ops = mv_port_info[board_idx].port_ops;
+
+        probe_ent->irq = pdev->irq;
+        probe_ent->irq_flags = SA_SHIRQ;
+        probe_ent->mmio_base = mmio_base;
+        probe_ent->private_data = hpriv;
+
+        /* initialize adapter */
+        rc = mv_host_init(probe_ent);
+        if (rc) {
+                goto err_out_hpriv;
+        }
+/*      mv_print_info(probe_ent); */
+
+        {
+                int b, w;
+                u32 dw[4];      /* hold a line of 16b */
+                VPRINTK("PCI config space:\n");
+                for (b = 0; b < 0x40; ) {
+                        for (w = 0; w < 4; w++) {
+                                (void) pci_read_config_dword(pdev,b,&dw[w]);
+                                b += sizeof(*dw);
+                        }
+                        VPRINTK("%08x %08x %08x %08x\n",
+                                dw[0],dw[1],dw[2],dw[3]);
+                }
+        }
+
+        /* FIXME: check ata_device_add return value */
+        ata_device_add(probe_ent);
+        kfree(probe_ent);
+
+        return 0;
+
+ err_out_hpriv:
+        kfree(hpriv);
+ err_out_iounmap:
+        iounmap(mmio_base);
+ err_out_free_ent:
+        kfree(probe_ent);
+ err_out_regions:
+        pci_release_regions(pdev);
+ err_out:
+        if (!pci_dev_busy) {
+                pci_disable_device(pdev);
+        }
+
+        return rc;
+}
+
+static int __init mv_init(void)
+{
+        return pci_module_init(&mv_pci_driver);
+}
+
+static void __exit mv_exit(void)
+{
+        pci_unregister_driver(&mv_pci_driver);
+}
+
+MODULE_AUTHOR("Brett Russ");
+MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
+
+module_init(mv_init);
+module_exit(mv_exit);
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index 029c2482e127..ffcdeb68641c 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -494,7 +494,7 @@ static int qs_port_start(struct ata_port *ap)
         if (rc)
                 return rc;
         qs_enter_reg_mode(ap);
-        pp = kcalloc(1, sizeof(*pp), GFP_KERNEL);
+        pp = kzalloc(sizeof(*pp), GFP_KERNEL);
         if (!pp) {
                 rc = -ENOMEM;
                 goto err_out;
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index 1566886815fb..42e13ed8eb5b 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -125,8 +125,8 @@ static struct ata_port_info uli_port_info = {
         .sht            = &uli_sht,
         .host_flags     = ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
                           ATA_FLAG_NO_LEGACY,
-        .pio_mask       = 0x03,         //support pio mode 4 (FIXME)
-        .udma_mask      = 0x7f,         //support udma mode 6
+        .pio_mask       = 0x1f,         /* pio0-4 */
+        .udma_mask      = 0x7f,         /* udma0-6 */
         .port_ops       = &uli_ops,
 };
 
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 9097f2f7b12a..2efb317153ce 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -40,7 +40,6 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/system.h>
-#include <asm/segment.h>
 #include <asm/delay.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/serial/68360serial.c b/drivers/serial/68360serial.c
index b116122e569a..170c9d2a749c 100644
--- a/drivers/serial/68360serial.c
+++ b/drivers/serial/68360serial.c
@@ -2474,8 +2474,7 @@ static struct tty_operations rs_360_ops = {
         .tiocmset = rs_360_tiocmset,
 };
 
-/* int __init rs_360_init(void) */
-int rs_360_init(void)
+static int __init rs_360_init(void)
 {
         struct serial_state * state;
         ser_info_t      *info;
@@ -2827,10 +2826,7 @@ int rs_360_init(void)
 
         return 0;
 }
-
-
-
-
+module_init(rs_360_init);
 
 /* This must always be called before the rs_360_init() function, otherwise
  * it blows away the port control information.
diff --git a/drivers/serial/crisv10.c b/drivers/serial/crisv10.c
index 5690594b257b..40d3e7139cfe 100644
--- a/drivers/serial/crisv10.c
+++ b/drivers/serial/crisv10.c
@@ -446,7 +446,6 @@ static char *serial_version = "$Revision: 1.25 $";
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/system.h>
-#include <asm/segment.h>
 #include <asm/bitops.h>
 #include <linux/delay.h>
 
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 79f8df4d66b7..eb31125c6a30 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -56,7 +56,6 @@
 #include <linux/bitops.h>
 
 #include <asm/system.h>
-#include <asm/segment.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
diff --git a/drivers/serial/mcfserial.c b/drivers/serial/mcfserial.c
index 8c40167778de..43b03c55f453 100644
--- a/drivers/serial/mcfserial.c
+++ b/drivers/serial/mcfserial.c
@@ -40,7 +40,6 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/system.h>
-#include <asm/segment.h>
 #include <asm/semaphore.h>
 #include <asm/delay.h>
 #include <asm/coldfire.h>
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index 32f808d157a1..8302376800c0 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -207,7 +207,7 @@ static void lh7a40xuart_tx_chars (struct uart_port* port)
                 return;
         }
         if (uart_circ_empty (xmit) || uart_tx_stopped (port)) {
-                lh7a40xuart_stop_tx (port, 0);
+                lh7a40xuart_stop_tx (port);
                 return;
         }
 
@@ -229,7 +229,7 @@ static void lh7a40xuart_tx_chars (struct uart_port* port)
                 uart_write_wakeup (port);
 
         if (uart_circ_empty (xmit))
-                lh7a40xuart_stop_tx (port, 0);
+                lh7a40xuart_stop_tx (port);
 }
 
 static void lh7a40xuart_modem_status (struct uart_port* port)
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index bb1db1959854..c466739428b2 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -960,7 +960,7 @@ int usbatm_usb_probe(struct usb_interface *intf, const struct usb_device_id *id,
                         intf->altsetting->desc.bInterfaceNumber);
 
         /* instance init */
-        instance = kcalloc(1, sizeof(*instance) + sizeof(struct urb *) * (num_rcv_urbs + num_snd_urbs), GFP_KERNEL);
+        instance = kzalloc(sizeof(*instance) + sizeof(struct urb *) * (num_rcv_urbs + num_snd_urbs), GFP_KERNEL);
         if (!instance) {
                 dev_dbg(dev, "%s: no memory for instance data!\n", __func__);
                 return -ENOMEM;
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 9f44e83c6a69..12ecdb03ee5f 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1669,7 +1669,7 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
 {
         struct usb_hcd *hcd;
 
-        hcd = kcalloc(1, sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
+        hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
         if (!hcd) {
                 dev_dbg (dev, "hcd alloc failed\n");
                 return NULL;
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index b56f25864ed6..4c972b57c7c3 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -638,7 +638,7 @@ iso_stream_alloc (unsigned mem_flags)
 {
         struct ehci_iso_stream *stream;
 
-        stream = kcalloc(1, sizeof *stream, mem_flags);
+        stream = kzalloc(sizeof *stream, mem_flags);
         if (likely (stream != NULL)) {
                 INIT_LIST_HEAD(&stream->td_list);
                 INIT_LIST_HEAD(&stream->free_list);
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 76cb496c5836..75128c371800 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -717,7 +717,7 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
         }
         /* avoid all allocations within spinlocks: request or endpoint */
         if (!hep->hcpriv) {
-                ep = kcalloc(1, sizeof *ep, mem_flags);
+                ep = kzalloc(sizeof *ep, mem_flags);
                 if (!ep)
                         return -ENOMEM;
         }
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 80eaf659c198..d2a1fd40dfcb 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -835,7 +835,7 @@ static int sl811h_urb_enqueue(
 
         /* avoid all allocations within spinlocks */
         if (!hep->hcpriv)
-                ep = kcalloc(1, sizeof *ep, mem_flags);
+                ep = kzalloc(sizeof *ep, mem_flags);
 
         spin_lock_irqsave(&sl811->lock, flags);
 
diff --git a/drivers/usb/input/acecad.c b/drivers/usb/input/acecad.c
index 13532f3e3efc..74f8760d7c07 100644
--- a/drivers/usb/input/acecad.c
+++ b/drivers/usb/input/acecad.c
@@ -152,7 +152,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
 
-        acecad = kcalloc(1, sizeof(struct usb_acecad), GFP_KERNEL);
+        acecad = kzalloc(sizeof(struct usb_acecad), GFP_KERNEL);
         if (!acecad)
                 return -ENOMEM;
 
diff --git a/drivers/usb/input/itmtouch.c b/drivers/usb/input/itmtouch.c
index 0dc439f10823..becb87efb869 100644
--- a/drivers/usb/input/itmtouch.c
+++ b/drivers/usb/input/itmtouch.c
@@ -166,7 +166,7 @@ static int itmtouch_probe(struct usb_interface *intf, const struct usb_device_id
         interface = intf->cur_altsetting;
         endpoint = &interface->endpoint[0].desc;
 
-        if (!(itmtouch = kcalloc(1, sizeof(struct itmtouch_dev), GFP_KERNEL))) {
+        if (!(itmtouch = kzalloc(sizeof(struct itmtouch_dev), GFP_KERNEL))) {
                 err("%s - Out of memory.", __FUNCTION__);
                 return -ENOMEM;
         }
diff --git a/drivers/usb/input/pid.c b/drivers/usb/input/pid.c
index 256963863478..acc71ec560e9 100644
--- a/drivers/usb/input/pid.c
+++ b/drivers/usb/input/pid.c
@@ -263,7 +263,7 @@ int hid_pid_init(struct hid_device *hid)
         struct hid_ff_pid *private;
         struct hid_input *hidinput = list_entry(&hid->inputs, struct hid_input, list);
 
-        private = hid->ff_private = kcalloc(1, sizeof(struct hid_ff_pid), GFP_KERNEL);
+        private = hid->ff_private = kzalloc(sizeof(struct hid_ff_pid), GFP_KERNEL);
         if (!private)
                 return -ENOMEM;
 
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 9aae884475be..4af321fae390 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -3,3 +3,4 @@
 obj-$(CONFIG_LCD_CLASS_DEVICE)     += lcd.o
 obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
 obj-$(CONFIG_BACKLIGHT_CORGI)   += corgi_bl.o
+obj-$(CONFIG_SHARP_LOCOMO)      += locomolcd.o
diff --git a/drivers/video/backlight/locomolcd.c b/drivers/video/backlight/locomolcd.c
new file mode 100644
index 000000000000..ada6e75eb048
--- /dev/null
+++ b/drivers/video/backlight/locomolcd.c
@@ -0,0 +1,157 @@
+/*
+ * Backlight control code for Sharp Zaurus SL-5500
+ *
+ * Copyright 2005 John Lenz <lenz@cs.wisc.edu>
+ * Maintainer: Pavel Machek <pavel@suse.cz> (unless John wants to :-)
+ * GPL v2
+ *
+ * This driver assumes single CPU. That's okay, because collie is
+ * slightly old hardware, and noone is going to retrofit second CPU to
+ * old PDA.
+ */
+
+/* LCD power functions */
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+
+#include <asm/hardware/locomo.h>
+#include <asm/irq.h>
+
+#ifdef CONFIG_SA1100_COLLIE
+#include <asm/arch/collie.h>
+#else
+#include <asm/arch/poodle.h>
+#endif
+
+extern void (*sa1100fb_lcd_power)(int on);
+
+static struct locomo_dev *locomolcd_dev;
+
+static void locomolcd_on(int comadj)
+{
+        locomo_gpio_set_dir(locomolcd_dev, LOCOMO_GPIO_LCD_VSHA_ON, 0);
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_VSHA_ON, 1);
+        mdelay(2);
+
+        locomo_gpio_set_dir(locomolcd_dev, LOCOMO_GPIO_LCD_VSHD_ON, 0);
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_VSHD_ON, 1);
+        mdelay(2);
+
+        locomo_m62332_senddata(locomolcd_dev, comadj, 0);
+        mdelay(5);
+
+        locomo_gpio_set_dir(locomolcd_dev, LOCOMO_GPIO_LCD_VEE_ON, 0);
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_VEE_ON, 1);
+        mdelay(10);
+
+        /* TFTCRST | CPSOUT=0 | CPSEN */
+        locomo_writel(0x01, locomolcd_dev->mapbase + LOCOMO_TC);
+
+        /* Set CPSD */
+        locomo_writel(6, locomolcd_dev->mapbase + LOCOMO_CPSD);
+
+        /* TFTCRST | CPSOUT=0 | CPSEN */
+        locomo_writel((0x04 | 0x01), locomolcd_dev->mapbase + LOCOMO_TC);
+        mdelay(10);
+
+        locomo_gpio_set_dir(locomolcd_dev, LOCOMO_GPIO_LCD_MOD, 0);
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_MOD, 1);
+}
+
+static void locomolcd_off(int comadj)
+{
+        /* TFTCRST=1 | CPSOUT=1 | CPSEN = 0 */
+        locomo_writel(0x06, locomolcd_dev->mapbase + LOCOMO_TC);
+        mdelay(1);
+
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_VSHA_ON, 0);
+        mdelay(110);
+
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_VEE_ON, 0);
+        mdelay(700);
+
+        /* TFTCRST=0 | CPSOUT=0 | CPSEN = 0 */
+        locomo_writel(0, locomolcd_dev->mapbase + LOCOMO_TC);
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_MOD, 0);
+        locomo_gpio_write(locomolcd_dev, LOCOMO_GPIO_LCD_VSHD_ON, 0);
+}
+
+void locomolcd_power(int on)
+{
+        int comadj = 118;
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        if (!locomolcd_dev) {
+                local_irq_restore(flags);
+                return;
+        }
+
+        /* read comadj */
+#ifdef CONFIG_MACH_POODLE
+        comadj = 118;
+#else
+        comadj = 128;
+#endif
+
+        if (on)
+                locomolcd_on(comadj);
+        else
+                locomolcd_off(comadj);
+
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL(locomolcd_power);
+
+static int poodle_lcd_probe(struct locomo_dev *dev)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        locomolcd_dev = dev;
+
+        /* the poodle_lcd_power function is called for the first time
+         * from fs_initcall, which is before locomo is activated.
+         * We need to recall poodle_lcd_power here*/
+#ifdef CONFIG_MACH_POODLE
+        locomolcd_power(1);
+#endif
+        local_irq_restore(flags);
+        return 0;
+}
+
+static int poodle_lcd_remove(struct locomo_dev *dev)
+{
+        unsigned long flags;
+        local_irq_save(flags);
+        locomolcd_dev = NULL;
+        local_irq_restore(flags);
+        return 0;
+}
+
+static struct locomo_driver poodle_lcd_driver = {
+        .drv = {
+                .name = "locomo-backlight",
+        },
+        .devid  = LOCOMO_DEVID_BACKLIGHT,
+        .probe  = poodle_lcd_probe,
+        .remove = poodle_lcd_remove,
+};
+
+static int __init poodle_lcd_init(void)
+{
+        int ret = locomo_driver_register(&poodle_lcd_driver);
+        if (ret) return ret;
+
+#ifdef CONFIG_SA1100_COLLIE
+        sa1100fb_lcd_power = locomolcd_power;
+#endif
+        return 0;
+}
+device_initcall(poodle_lcd_init);
+
diff --git a/drivers/video/q40fb.c b/drivers/video/q40fb.c
index 71b69da0c40d..162012bb9264 100644
--- a/drivers/video/q40fb.c
+++ b/drivers/video/q40fb.c
@@ -21,7 +21,6 @@
 
 #include <asm/uaccess.h>
 #include <asm/setup.h>
-#include <asm/segment.h>
 #include <asm/system.h>
 #include <asm/q40_master.h>
 #include <linux/fb.h>
diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c
index adcda697ea60..0030c071da8f 100644
--- a/drivers/video/w100fb.c
+++ b/drivers/video/w100fb.c
@@ -5,9 +5,15 @@
  *
  * Copyright (C) 2002, ATI Corp.
  * Copyright (C) 2004-2005 Richard Purdie
+ * Copyright (c) 2005 Ian Molton
  *
  * Rewritten for 2.6 by Richard Purdie <rpurdie@rpsys.net>
  *
+ * Generic platform support by Ian Molton <spyro@f2s.com>
+ * and Richard Purdie <rpurdie@rpsys.net>
+ *
+ * w32xx support by Ian Molton
+ *
  * 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.
@@ -21,7 +27,7 @@
 #include <linux/mm.h>
 #include <linux/device.h>
 #include <linux/string.h>
-#include <linux/proc_fs.h>
+#include <linux/vmalloc.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <video/w100fb.h>
@@ -30,114 +36,78 @@
 /*
  * Prototypes
  */
-static void w100fb_save_buffer(void);
-static void w100fb_clear_buffer(void);
-static void w100fb_restore_buffer(void);
-static void w100fb_clear_screen(u32 mode, long int offset);
-static void w100_resume(void);
 static void w100_suspend(u32 mode);
-static void w100_init_qvga_rotation(u16 deg);
-static void w100_init_vga_rotation(u16 deg);
 static void w100_vsync(void);
-static void w100_init_sharp_lcd(u32 mode);
-static void w100_pwm_setup(void);
-static void w100_InitExtMem(u32 mode);
-static void w100_hw_init(void);
-static u16 w100_set_fastsysclk(u16 Freq);
-
-static void lcdtg_hw_init(u32 mode);
-static void lcdtg_lcd_change(u32 mode);
-static void lcdtg_resume(void);
-static void lcdtg_suspend(void);
-
-
-/* Register offsets & lengths */
-#define REMAPPED_FB_LEN   0x15ffff
-
-#define BITS_PER_PIXEL    16
+static void w100_hw_init(struct w100fb_par*);
+static void w100_pwm_setup(struct w100fb_par*);
+static void w100_init_clocks(struct w100fb_par*);
+static void w100_setup_memory(struct w100fb_par*);
+static void w100_init_lcd(struct w100fb_par*);
+static void w100_set_dispregs(struct w100fb_par*);
+static void w100_update_enable(void);
+static void w100_update_disable(void);
+static void calc_hsync(struct w100fb_par *par);
+struct w100_pll_info *w100_get_xtal_table(unsigned int freq);
 
 /* Pseudo palette size */
 #define MAX_PALETTES      16
 
-/* for resolution change */
-#define LCD_MODE_INIT (-1)
-#define LCD_MODE_480    0
-#define LCD_MODE_320    1
-#define LCD_MODE_240    2
-#define LCD_MODE_640    3
-
-#define LCD_SHARP_QVGA 0
-#define LCD_SHARP_VGA  1
-
-#define LCD_MODE_PORTRAIT       0
-#define LCD_MODE_LANDSCAPE      1
-
 #define W100_SUSPEND_EXTMEM 0
 #define W100_SUSPEND_ALL    1
 
-/* General frame buffer data structures */
-struct w100fb_par {
-        u32 xres;
-        u32 yres;
-        int fastsysclk_mode;
-        int lcdMode;
-        int rotation_flag;
-        int blanking_flag;
-        int comadj;
-        int phadadj;
-};
-
-static struct w100fb_par *current_par;
+#define BITS_PER_PIXEL    16
 
 /* Remapped addresses for base cfg, memmapped regs and the frame buffer itself */
 static void *remapped_base;
 static void *remapped_regs;
 static void *remapped_fbuf;
 
-/* External Function */
-static void(*w100fb_ssp_send)(u8 adrs, u8 data);
+#define REMAPPED_FB_LEN   0x15ffff
+
+/* This is the offset in the w100's address space we map the current
+   framebuffer memory to. We use the position of external memory as
+   we can remap internal memory to there if external isn't present. */
+#define W100_FB_BASE MEM_EXT_BASE_VALUE
+
 
 /*
  * Sysfs functions
  */
-
-static ssize_t rotation_show(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t flip_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct fb_info *info = dev_get_drvdata(dev);
         struct w100fb_par *par=info->par;
 
-        return sprintf(buf, "%d\n",par->rotation_flag);
+        return sprintf(buf, "%d\n",par->flip);
 }
 
-static ssize_t rotation_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+static ssize_t flip_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        unsigned int rotate;
+        unsigned int flip;
         struct fb_info *info = dev_get_drvdata(dev);
         struct w100fb_par *par=info->par;
 
-        rotate = simple_strtoul(buf, NULL, 10);
+        flip = simple_strtoul(buf, NULL, 10);
+
+        if (flip > 0)
+                par->flip = 1;
+        else
+                par->flip = 0;
 
-        if (rotate > 0) par->rotation_flag = 1;
-        else par->rotation_flag = 0;
+        w100_update_disable();
+        w100_set_dispregs(par);
+        w100_update_enable();
 
-        if (par->lcdMode == LCD_MODE_320)
-                w100_init_qvga_rotation(par->rotation_flag ? 270 : 90);
-        else if (par->lcdMode == LCD_MODE_240)
-                w100_init_qvga_rotation(par->rotation_flag ? 180 : 0);
-        else if (par->lcdMode == LCD_MODE_640)
-                w100_init_vga_rotation(par->rotation_flag ? 270 : 90);
-        else if (par->lcdMode == LCD_MODE_480)
-                w100_init_vga_rotation(par->rotation_flag ? 180 : 0);
+        calc_hsync(par);
 
         return count;
 }
 
-static DEVICE_ATTR(rotation, 0644, rotation_show, rotation_store);
+static DEVICE_ATTR(flip, 0644, flip_show, flip_store);
 
 static ssize_t w100fb_reg_read(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        unsigned long param;
-        unsigned long regs;
+        unsigned long regs, param;
         regs = simple_strtoul(buf, NULL, 16);
         param = readl(remapped_regs + regs);
         printk("Read Register 0x%08lX: 0x%08lX\n", regs, param);
@@ -148,8 +118,7 @@ static DEVICE_ATTR(reg_read, 0200, NULL, w100fb_reg_read);
 
 static ssize_t w100fb_reg_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        unsigned long regs;
-        unsigned long param;
+        unsigned long regs, param;
         sscanf(buf, "%lx %lx", &regs, &param);
 
         if (regs <= 0x2000) {
@@ -163,54 +132,56 @@ static ssize_t w100fb_reg_write(struct device *dev, struct device_attribute *att
 static DEVICE_ATTR(reg_write, 0200, NULL, w100fb_reg_write);
 
 
-static ssize_t fastsysclk_show(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t fastpllclk_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct fb_info *info = dev_get_drvdata(dev);
         struct w100fb_par *par=info->par;
 
-        return sprintf(buf, "%d\n",par->fastsysclk_mode);
+        return sprintf(buf, "%d\n",par->fastpll_mode);
 }
 
-static ssize_t fastsysclk_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+static ssize_t fastpllclk_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        int param;
         struct fb_info *info = dev_get_drvdata(dev);
         struct w100fb_par *par=info->par;
 
-        param = simple_strtoul(buf, NULL, 10);
-
-        if (param == 75) {
-                printk("Set fastsysclk %d\n", param);
-                par->fastsysclk_mode = param;
-                w100_set_fastsysclk(par->fastsysclk_mode);
-        } else if (param == 100) {
-                printk("Set fastsysclk %d\n", param);
-                par->fastsysclk_mode = param;
-                w100_set_fastsysclk(par->fastsysclk_mode);
+        if (simple_strtoul(buf, NULL, 10) > 0) {
+                par->fastpll_mode=1;
+                printk("w100fb: Using fast system clock (if possible)\n");
+        } else {
+                par->fastpll_mode=0;
+                printk("w100fb: Using normal system clock\n");
         }
+
+        w100_init_clocks(par);
+        calc_hsync(par);
+
         return count;
 }
 
-static DEVICE_ATTR(fastsysclk, 0644, fastsysclk_show, fastsysclk_store);
+static DEVICE_ATTR(fastpllclk, 0644, fastpllclk_show, fastpllclk_store);
 
 /*
- * The touchscreen on this device needs certain information
- * from the video driver to function correctly. We export it here.
+ * Some touchscreens need hsync information from the video driver to
+ * function correctly. We export it here.
  */
-int w100fb_get_xres(void) {
-        return current_par->xres;
-}
+unsigned long w100fb_get_hsynclen(struct device *dev)
+{
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct w100fb_par *par=info->par;
 
-int w100fb_get_blanking(void) {
-        return current_par->blanking_flag;
+        /* If display is blanked/suspended, hsync isn't active */
+        if (par->blanked)
+                return 0;
+        else
+                return par->hsync_len;
 }
+EXPORT_SYMBOL(w100fb_get_hsynclen);
 
-int w100fb_get_fastsysclk(void) {
-        return current_par->fastsysclk_mode;
+static void w100fb_clear_screen(struct w100fb_par *par)
+{
+        memset_io(remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), 0, (par->xres * par->yres * BITS_PER_PIXEL/8));
 }
-EXPORT_SYMBOL(w100fb_get_xres);
-EXPORT_SYMBOL(w100fb_get_blanking);
-EXPORT_SYMBOL(w100fb_get_fastsysclk);
 
 
 /*
@@ -234,7 +205,6 @@ static int w100fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
          * according to the RGB bitfield information.
          */
         if (regno < MAX_PALETTES) {
-
                 u32 *pal = info->pseudo_palette;
 
                 val = (red & 0xf800) | ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11);
@@ -250,115 +220,90 @@ static int w100fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  */
 static int w100fb_blank(int blank_mode, struct fb_info *info)
 {
-        struct w100fb_par *par;
-        par=info->par;
+        struct w100fb_par *par = info->par;
+        struct w100_tg_info *tg = par->mach->tg;
 
         switch(blank_mode) {
 
-        case FB_BLANK_NORMAL: /* Normal blanking */
-        case FB_BLANK_VSYNC_SUSPEND: /* VESA blank (vsync off) */
-        case FB_BLANK_HSYNC_SUSPEND: /* VESA blank (hsync off) */
-        case FB_BLANK_POWERDOWN: /* Poweroff */
-                if (par->blanking_flag == 0) {
-                        w100fb_save_buffer();
-                        lcdtg_suspend();
-                        par->blanking_flag = 1;
+        case FB_BLANK_NORMAL:         /* Normal blanking */
+        case FB_BLANK_VSYNC_SUSPEND:  /* VESA blank (vsync off) */
+        case FB_BLANK_HSYNC_SUSPEND:  /* VESA blank (hsync off) */
+        case FB_BLANK_POWERDOWN:      /* Poweroff */
+                if (par->blanked == 0) {
+                        if(tg && tg->suspend)
+                                tg->suspend(par);
+                        par->blanked = 1;
                 }
                 break;
 
         case FB_BLANK_UNBLANK: /* Unblanking */
-                if (par->blanking_flag != 0) {
-                        w100fb_restore_buffer();
-                        lcdtg_resume();
-                        par->blanking_flag = 0;
+                if (par->blanked != 0) {
+                        if(tg && tg->resume)
+                                tg->resume(par);
+                        par->blanked = 0;
                 }
                 break;
         }
         return 0;
 }
 
+
 /*
  *  Change the resolution by calling the appropriate hardware functions
  */
-static void w100fb_changeres(int rotate_mode, u32 mode)
+static void w100fb_activate_var(struct w100fb_par *par)
 {
-        u16 rotation=0;
-
-        switch(rotate_mode) {
-        case LCD_MODE_LANDSCAPE:
-                rotation=(current_par->rotation_flag ? 270 : 90);
-                break;
-        case LCD_MODE_PORTRAIT:
-                rotation=(current_par->rotation_flag ? 180 : 0);
-                break;
-        }
+        struct w100_tg_info *tg = par->mach->tg;
 
-        w100_pwm_setup();
-        switch(mode) {
-        case LCD_SHARP_QVGA:
-                w100_vsync();
-                w100_suspend(W100_SUSPEND_EXTMEM);
-                w100_init_sharp_lcd(LCD_SHARP_QVGA);
-                w100_init_qvga_rotation(rotation);
-                w100_InitExtMem(LCD_SHARP_QVGA);
-                w100fb_clear_screen(LCD_SHARP_QVGA, 0);
-                lcdtg_lcd_change(LCD_SHARP_QVGA);
-                break;
-        case LCD_SHARP_VGA:
-                w100fb_clear_screen(LCD_SHARP_QVGA, 0);
-                writel(0xBFFFA000, remapped_regs + mmMC_EXT_MEM_LOCATION);
-                w100_InitExtMem(LCD_SHARP_VGA);
-                w100fb_clear_screen(LCD_SHARP_VGA, 0x200000);
-                w100_vsync();
-                w100_init_sharp_lcd(LCD_SHARP_VGA);
-                if (rotation != 0)
-                        w100_init_vga_rotation(rotation);
-                lcdtg_lcd_change(LCD_SHARP_VGA);
-                break;
-        }
+        w100_pwm_setup(par);
+        w100_setup_memory(par);
+        w100_init_clocks(par);
+        w100fb_clear_screen(par);
+        w100_vsync();
+
+        w100_update_disable();
+        w100_init_lcd(par);
+        w100_set_dispregs(par);
+        w100_update_enable();
+
+        calc_hsync(par);
+
+        if (!par->blanked && tg && tg->change)
+                tg->change(par);
 }
 
-/*
- * Set up the display for the fb subsystem
+
+/* Select the smallest mode that allows the desired resolution to be
+ * displayed. If desired, the x and y parameters can be rounded up to
+ * match the selected mode.
  */
-static void w100fb_activate_var(struct fb_info *info)
+static struct w100_mode *w100fb_get_mode(struct w100fb_par *par, unsigned int *x, unsigned int *y, int saveval)
 {
-        u32 temp32;
-        struct w100fb_par *par=info->par;
-        struct fb_var_screeninfo *var = &info->var;
+        struct w100_mode *mode = NULL;
+        struct w100_mode *modelist = par->mach->modelist;
+        unsigned int best_x = 0xffffffff, best_y = 0xffffffff;
+        unsigned int i;
+
+        for (i = 0 ; i < par->mach->num_modes ; i++) {
+                if (modelist[i].xres >= *x && modelist[i].yres >= *y &&
+                                modelist[i].xres < best_x && modelist[i].yres < best_y) {
+                        best_x = modelist[i].xres;
+                        best_y = modelist[i].yres;
+                        mode = &modelist[i];
+                } else if(modelist[i].xres >= *y && modelist[i].yres >= *x &&
+                        modelist[i].xres < best_y && modelist[i].yres < best_x) {
+                        best_x = modelist[i].yres;
+                        best_y = modelist[i].xres;
+                        mode = &modelist[i];
+                }
+        }
 
-        /* Set the hardware to 565 */
-        temp32 = readl(remapped_regs + mmDISP_DEBUG2);
-        temp32 &= 0xff7fffff;
-        temp32 |= 0x00800000;
-        writel(temp32, remapped_regs + mmDISP_DEBUG2);
+        if (mode && saveval) {
+                *x = best_x;
+                *y = best_y;
+        }
 
-        if (par->lcdMode == LCD_MODE_INIT) {
-                w100_init_sharp_lcd(LCD_SHARP_VGA);
-                w100_init_vga_rotation(par->rotation_flag ? 270 : 90);
-                par->lcdMode = LCD_MODE_640;
-                lcdtg_hw_init(LCD_SHARP_VGA);
-        } else if (var->xres == 320 && var->yres == 240) {
-                if (par->lcdMode != LCD_MODE_320) {
-                        w100fb_changeres(LCD_MODE_LANDSCAPE, LCD_SHARP_QVGA);
-                        par->lcdMode = LCD_MODE_320;
-                }
-        } else if (var->xres == 240 && var->yres == 320) {
-                if (par->lcdMode != LCD_MODE_240) {
-                        w100fb_changeres(LCD_MODE_PORTRAIT, LCD_SHARP_QVGA);
-                        par->lcdMode = LCD_MODE_240;
-                }
-        } else if (var->xres == 640 && var->yres == 480) {
-                if (par->lcdMode != LCD_MODE_640) {
-                        w100fb_changeres(LCD_MODE_LANDSCAPE, LCD_SHARP_VGA);
-                        par->lcdMode = LCD_MODE_640;
-                }
-        } else if (var->xres == 480 && var->yres == 640) {
-                if (par->lcdMode != LCD_MODE_480) {
-                        w100fb_changeres(LCD_MODE_PORTRAIT, LCD_SHARP_VGA);
-                        par->lcdMode = LCD_MODE_480;
-                }
-        } else printk(KERN_ERR "W100FB: Resolution error!\n");
+        return mode;
 }
 
 
@@ -366,31 +311,19 @@ static void w100fb_activate_var(struct fb_info *info)
  *  w100fb_check_var():
  *  Get the video params out of 'var'. If a value doesn't fit, round it up,
  *  if it's too big, return -EINVAL.
- *
  */
 static int w100fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
-        if (var->xres < var->yres) { /* Portrait mode */
-                if ((var->xres > 480) || (var->yres > 640)) {
-                        return -EINVAL;
-                } else if ((var->xres > 240) || (var->yres > 320)) {
-                        var->xres = 480;
-                        var->yres = 640;
-                } else {
-                        var->xres = 240;
-                        var->yres = 320;
-                }
-        } else { /* Landscape mode */
-                if ((var->xres > 640) || (var->yres > 480)) {
-                        return -EINVAL;
-                } else if ((var->xres > 320) || (var->yres > 240)) {
-                        var->xres = 640;
-                        var->yres = 480;
-                } else {
-                        var->xres = 320;
-                        var->yres = 240;
-                }
-        }
+        struct w100fb_par *par=info->par;
+
+        if(!w100fb_get_mode(par, &var->xres, &var->yres, 1))
+                return -EINVAL;
+
+        if (par->mach->mem && ((var->xres*var->yres*BITS_PER_PIXEL/8) > (par->mach->mem->size+1)))
+                return -EINVAL;
+
+        if (!par->mach->mem && ((var->xres*var->yres*BITS_PER_PIXEL/8) > (MEM_INT_SIZE+1)))
+                return -EINVAL;
 
         var->xres_virtual = max(var->xres_virtual, var->xres);
         var->yres_virtual = max(var->yres_virtual, var->yres);
@@ -409,13 +342,11 @@ static int w100fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
         var->transp.offset = var->transp.length = 0;
 
         var->nonstd = 0;
-
         var->height = -1;
         var->width = -1;
         var->vmode = FB_VMODE_NONINTERLACED;
-
         var->sync = 0;
-        var->pixclock = 0x04;   /* 171521; */
+        var->pixclock = 0x04;  /* 171521; */
 
         return 0;
 }
@@ -430,274 +361,286 @@ static int w100fb_set_par(struct fb_info *info)
 {
         struct w100fb_par *par=info->par;
 
-        par->xres = info->var.xres;
-        par->yres = info->var.yres;
-
-        info->fix.visual = FB_VISUAL_TRUECOLOR;
-
-        info->fix.ypanstep = 0;
-        info->fix.ywrapstep = 0;
+        if (par->xres != info->var.xres || par->yres != info->var.yres) {
+                par->xres = info->var.xres;
+                par->yres = info->var.yres;
+                par->mode = w100fb_get_mode(par, &par->xres, &par->yres, 0);
 
-        if (par->blanking_flag)
-                w100fb_clear_buffer();
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
+                info->fix.ypanstep = 0;
+                info->fix.ywrapstep = 0;
+                info->fix.line_length = par->xres * BITS_PER_PIXEL / 8;
 
-        w100fb_activate_var(info);
+                if ((par->xres*par->yres*BITS_PER_PIXEL/8) > (MEM_INT_SIZE+1)) {
+                        par->extmem_active = 1;
+                        info->fix.smem_len = par->mach->mem->size+1;
+                } else {
+                        par->extmem_active = 0;
+                        info->fix.smem_len = MEM_INT_SIZE+1;
+                }
 
-        if (par->lcdMode == LCD_MODE_480) {
-                info->fix.line_length = (480 * BITS_PER_PIXEL) / 8;
-                info->fix.smem_len = 0x200000;
-        } else if (par->lcdMode == LCD_MODE_320) {
-                info->fix.line_length = (320 * BITS_PER_PIXEL) / 8;
-                info->fix.smem_len = 0x60000;
-        } else if (par->lcdMode == LCD_MODE_240) {
-                info->fix.line_length = (240 * BITS_PER_PIXEL) / 8;
-                info->fix.smem_len = 0x60000;
-        } else if (par->lcdMode == LCD_MODE_INIT || par->lcdMode == LCD_MODE_640) {
-                info->fix.line_length = (640 * BITS_PER_PIXEL) / 8;
-                info->fix.smem_len = 0x200000;
+                w100fb_activate_var(par);
         }
-
         return 0;
 }
 
 
 /*
- *      Frame buffer operations
+ *  Frame buffer operations
  */
 static struct fb_ops w100fb_ops = {
-        .owner = THIS_MODULE,
+        .owner        = THIS_MODULE,
         .fb_check_var = w100fb_check_var,
-        .fb_set_par = w100fb_set_par,
+        .fb_set_par   = w100fb_set_par,
         .fb_setcolreg = w100fb_setcolreg,
-        .fb_blank = w100fb_blank,
-        .fb_fillrect = cfb_fillrect,
-        .fb_copyarea = cfb_copyarea,
+        .fb_blank     = w100fb_blank,
+        .fb_fillrect  = cfb_fillrect,
+        .fb_copyarea  = cfb_copyarea,
         .fb_imageblit = cfb_imageblit,
-        .fb_cursor = soft_cursor,
+        .fb_cursor    = soft_cursor,
 };
 
-
-static void w100fb_clear_screen(u32 mode, long int offset)
+#ifdef CONFIG_PM
+static void w100fb_save_vidmem(struct w100fb_par *par)
 {
-        int i, numPix = 0;
-
-        if (mode == LCD_SHARP_VGA)
-                numPix = 640 * 480;
-        else if (mode == LCD_SHARP_QVGA)
-                numPix = 320 * 240;
+        int memsize;
 
-        for (i = 0; i < numPix; i++)
-                writew(0xffff, remapped_fbuf + offset + (2*i));
-}
-
-
-/* Need to split up the buffers to stay within the limits of kmalloc */
-#define W100_BUF_NUM    6
-static uint32_t *gSaveImagePtr[W100_BUF_NUM] = { NULL };
-
-static void w100fb_save_buffer(void)
-{
-        int i, j, bufsize;
-
-        bufsize=(current_par->xres * current_par->yres * BITS_PER_PIXEL / 8) / W100_BUF_NUM;
-        for (i = 0; i < W100_BUF_NUM; i++) {
-                if (gSaveImagePtr[i] == NULL)
-                        gSaveImagePtr[i] = kmalloc(bufsize, GFP_KERNEL);
-                if (gSaveImagePtr[i] == NULL) {
-                        w100fb_clear_buffer();
-                        printk(KERN_WARNING "can't alloc pre-off image buffer %d\n", i);
-                        break;
-                }
-                for (j = 0; j < bufsize/4; j++)
-                        *(gSaveImagePtr[i] + j) = readl(remapped_fbuf + (bufsize*i) + j*4);
+        if (par->extmem_active) {
+                memsize=par->mach->mem->size;
+                par->saved_extmem = vmalloc(memsize);
+                if (par->saved_extmem)
+                        memcpy_fromio(par->saved_extmem, remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), memsize);
         }
+        memsize=MEM_INT_SIZE;
+        par->saved_intmem = vmalloc(memsize);
+        if (par->saved_intmem && par->extmem_active)
+                memcpy_fromio(par->saved_intmem, remapped_fbuf + (W100_FB_BASE-MEM_INT_BASE_VALUE), memsize);
+        else if (par->saved_intmem)
+                memcpy_fromio(par->saved_intmem, remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), memsize);
 }
 
-
-static void w100fb_restore_buffer(void)
+static void w100fb_restore_vidmem(struct w100fb_par *par)
 {
-        int i, j, bufsize;
+        int memsize;
 
-        bufsize=(current_par->xres * current_par->yres * BITS_PER_PIXEL / 8) / W100_BUF_NUM;
-        for (i = 0; i < W100_BUF_NUM; i++) {
-                if (gSaveImagePtr[i] == NULL) {
-                        printk(KERN_WARNING "can't find pre-off image buffer %d\n", i);
-                        w100fb_clear_buffer();
-                        break;
-                }
-                for (j = 0; j < (bufsize/4); j++)
-                        writel(*(gSaveImagePtr[i] + j),remapped_fbuf + (bufsize*i) + (j*4));
-                kfree(gSaveImagePtr[i]);
-                gSaveImagePtr[i] = NULL;
+        if (par->extmem_active && par->saved_extmem) {
+                memsize=par->mach->mem->size;
+                memcpy_toio(remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), par->saved_extmem, memsize);
+                vfree(par->saved_extmem);
         }
-}
-
-
-static void w100fb_clear_buffer(void)
-{
-        int i;
-        for (i = 0; i < W100_BUF_NUM; i++) {
-                kfree(gSaveImagePtr[i]);
-                gSaveImagePtr[i] = NULL;
+        if (par->saved_intmem) {
+                memsize=MEM_INT_SIZE;
+                if (par->extmem_active)
+                        memcpy_toio(remapped_fbuf + (W100_FB_BASE-MEM_INT_BASE_VALUE), par->saved_intmem, memsize);
+                else
+                        memcpy_toio(remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE), par->saved_intmem, memsize);
+                vfree(par->saved_intmem);
         }
 }
 
-
-#ifdef CONFIG_PM
-static int w100fb_suspend(struct device *dev, pm_message_t state, u32 level)
+static int w100fb_suspend(struct device *dev, pm_message_t state, uint32_t level)
 {
         if (level == SUSPEND_POWER_DOWN) {
                 struct fb_info *info = dev_get_drvdata(dev);
                 struct w100fb_par *par=info->par;
+                struct w100_tg_info *tg = par->mach->tg;
 
-                w100fb_save_buffer();
-                lcdtg_suspend();
+                w100fb_save_vidmem(par);
+                if(tg && tg->suspend)
+                        tg->suspend(par);
                 w100_suspend(W100_SUSPEND_ALL);
-                par->blanking_flag = 1;
+                par->blanked = 1;
         }
         return 0;
 }
 
-static int w100fb_resume(struct device *dev, u32 level)
+static int w100fb_resume(struct device *dev, uint32_t level)
 {
         if (level == RESUME_POWER_ON) {
                 struct fb_info *info = dev_get_drvdata(dev);
                 struct w100fb_par *par=info->par;
-
-                w100_resume();
-                w100fb_restore_buffer();
-                lcdtg_resume();
-                par->blanking_flag = 0;
+                struct w100_tg_info *tg = par->mach->tg;
+
+                w100_hw_init(par);
+                w100fb_activate_var(par);
+                w100fb_restore_vidmem(par);
+                if(tg && tg->resume)
+                        tg->resume(par);
+                par->blanked = 0;
         }
         return 0;
 }
 #else
-#define w100fb_suspend  NULL
-#define w100fb_resume   NULL
+#define w100fb_suspend  NULL
+#define w100fb_resume   NULL
 #endif
 
 
 int __init w100fb_probe(struct device *dev)
 {
+        int err = -EIO;
         struct w100fb_mach_info *inf;
-        struct fb_info *info;
+        struct fb_info *info = NULL;
         struct w100fb_par *par;
         struct platform_device *pdev = to_platform_device(dev);
         struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        unsigned int chip_id;
 
         if (!mem)
                 return -EINVAL;
 
-        /* remap the areas we're going to use */
+        /* Remap the chip base address */
         remapped_base = ioremap_nocache(mem->start+W100_CFG_BASE, W100_CFG_LEN);
         if (remapped_base == NULL)
-                return -EIO;
+                goto out;
 
+        /* Map the register space */
         remapped_regs = ioremap_nocache(mem->start+W100_REG_BASE, W100_REG_LEN);
-        if (remapped_regs == NULL) {
-                iounmap(remapped_base);
-                return -EIO;
+        if (remapped_regs == NULL)
+                goto out;
+
+        /* Identify the chip */
+        printk("Found ");
+        chip_id = readl(remapped_regs + mmCHIP_ID);
+        switch(chip_id) {
+                case CHIP_ID_W100:  printk("w100");  break;
+                case CHIP_ID_W3200: printk("w3200"); break;
+                case CHIP_ID_W3220: printk("w3220"); break;
+                default:
+                        printk("Unknown imageon chip ID\n");
+                        err = -ENODEV;
+                        goto out;
         }
+        printk(" at 0x%08lx.\n", mem->start+W100_CFG_BASE);
 
-        remapped_fbuf = ioremap_nocache(mem->start+MEM_EXT_BASE_VALUE, REMAPPED_FB_LEN);
-        if (remapped_fbuf == NULL) {
-                iounmap(remapped_base);
-                iounmap(remapped_regs);
-                return -EIO;
-        }
+        /* Remap the framebuffer */
+        remapped_fbuf = ioremap_nocache(mem->start+MEM_WINDOW_BASE, MEM_WINDOW_SIZE);
+        if (remapped_fbuf == NULL)
+                goto out;
 
         info=framebuffer_alloc(sizeof(struct w100fb_par), dev);
         if (!info) {
-                iounmap(remapped_base);
-                iounmap(remapped_regs);
-                iounmap(remapped_fbuf);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto out;
         }
 
-        info->device=dev;
         par = info->par;
-        current_par=info->par;
         dev_set_drvdata(dev, info);
 
         inf = dev->platform_data;
-        par->phadadj = inf->phadadj;
-        par->comadj = inf->comadj;
-        par->fastsysclk_mode = 75;
-        par->lcdMode = LCD_MODE_INIT;
-        par->rotation_flag=0;
-        par->blanking_flag=0;
-        w100fb_ssp_send = inf->w100fb_ssp_send;
-
-        w100_hw_init();
-        w100_pwm_setup();
+        par->chip_id = chip_id;
+        par->mach = inf;
+        par->fastpll_mode = 0;
+        par->blanked = 0;
+
+        par->pll_table=w100_get_xtal_table(inf->xtal_freq);
+        if (!par->pll_table) {
+                printk(KERN_ERR "No matching Xtal definition found\n");
+                err = -EINVAL;
+                goto out;
+        }
 
         info->pseudo_palette = kmalloc(sizeof (u32) * MAX_PALETTES, GFP_KERNEL);
         if (!info->pseudo_palette) {
-                iounmap(remapped_base);
-                iounmap(remapped_regs);
-                iounmap(remapped_fbuf);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto out;
         }
 
         info->fbops = &w100fb_ops;
         info->flags = FBINFO_DEFAULT;
         info->node = -1;
-        info->screen_base = remapped_fbuf;
+        info->screen_base = remapped_fbuf + (W100_FB_BASE-MEM_WINDOW_BASE);
         info->screen_size = REMAPPED_FB_LEN;
 
-        info->var.xres = 640;
+        strcpy(info->fix.id, "w100fb");
+        info->fix.type = FB_TYPE_PACKED_PIXELS;
+        info->fix.type_aux = 0;
+        info->fix.accel = FB_ACCEL_NONE;
+        info->fix.smem_start = mem->start+W100_FB_BASE;
+        info->fix.mmio_start = mem->start+W100_REG_BASE;
+        info->fix.mmio_len = W100_REG_LEN;
+
+        if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        par->mode = &inf->modelist[0];
+        if(inf->init_mode & INIT_MODE_ROTATED) {
+                info->var.xres = par->mode->yres;
+                info->var.yres = par->mode->xres;
+        }
+        else {
+                info->var.xres = par->mode->xres;
+                info->var.yres = par->mode->yres;
+        }
+
+        if(inf->init_mode &= INIT_MODE_FLIPPED)
+                par->flip = 1;
+        else
+                par->flip = 0;
+
         info->var.xres_virtual = info->var.xres;
-        info->var.yres = 480;
         info->var.yres_virtual = info->var.yres;
-        info->var.pixclock = 0x04;      /* 171521; */
+        info->var.pixclock = 0x04;  /* 171521; */
         info->var.sync = 0;
         info->var.grayscale = 0;
         info->var.xoffset = info->var.yoffset = 0;
         info->var.accel_flags = 0;
         info->var.activate = FB_ACTIVATE_NOW;
 
-        strcpy(info->fix.id, "w100fb");
-        info->fix.type = FB_TYPE_PACKED_PIXELS;
-        info->fix.type_aux = 0;
-        info->fix.accel = FB_ACCEL_NONE;
-        info->fix.smem_start = mem->start+MEM_EXT_BASE_VALUE;
-        info->fix.mmio_start = mem->start+W100_REG_BASE;
-        info->fix.mmio_len = W100_REG_LEN;
+        w100_hw_init(par);
+
+        if (w100fb_check_var(&info->var, info) < 0) {
+                err = -EINVAL;
+                goto out;
+        }
 
-        w100fb_check_var(&info->var, info);
         w100fb_set_par(info);
 
         if (register_framebuffer(info) < 0) {
-                kfree(info->pseudo_palette);
-                iounmap(remapped_base);
-                iounmap(remapped_regs);
-                iounmap(remapped_fbuf);
-                return -EINVAL;
+                err = -EINVAL;
+                goto out;
         }
 
-        device_create_file(dev, &dev_attr_fastsysclk);
+        device_create_file(dev, &dev_attr_fastpllclk);
         device_create_file(dev, &dev_attr_reg_read);
         device_create_file(dev, &dev_attr_reg_write);
-        device_create_file(dev, &dev_attr_rotation);
+        device_create_file(dev, &dev_attr_flip);
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
         return 0;
+out:
+        fb_dealloc_cmap(&info->cmap);
+        kfree(info->pseudo_palette);
+        if (remapped_fbuf != NULL)
+                iounmap(remapped_fbuf);
+        if (remapped_regs != NULL)
+                iounmap(remapped_regs);
+        if (remapped_base != NULL)
+                iounmap(remapped_base);
+        if (info)
+                framebuffer_release(info);
+        return err;
 }
 
 
 static int w100fb_remove(struct device *dev)
 {
         struct fb_info *info = dev_get_drvdata(dev);
+        struct w100fb_par *par=info->par;
 
-        device_remove_file(dev, &dev_attr_fastsysclk);
+        device_remove_file(dev, &dev_attr_fastpllclk);
         device_remove_file(dev, &dev_attr_reg_read);
         device_remove_file(dev, &dev_attr_reg_write);
-        device_remove_file(dev, &dev_attr_rotation);
+        device_remove_file(dev, &dev_attr_flip);
 
         unregister_framebuffer(info);
 
-        w100fb_clear_buffer();
+        vfree(par->saved_intmem);
+        vfree(par->saved_extmem);
         kfree(info->pseudo_palette);
+        fb_dealloc_cmap(&info->cmap);
 
         iounmap(remapped_base);
         iounmap(remapped_regs);
@@ -721,10 +664,54 @@ static void w100_soft_reset(void)
         udelay(100);
 }
 
+static void w100_update_disable(void)
+{
+        union disp_db_buf_cntl_wr_u disp_db_buf_wr_cntl;
+
+        /* Prevent display updates */
+        disp_db_buf_wr_cntl.f.db_buf_cntl = 0x1e;
+        disp_db_buf_wr_cntl.f.update_db_buf = 0;
+        disp_db_buf_wr_cntl.f.en_db_buf = 0;
+        writel((u32) (disp_db_buf_wr_cntl.val), remapped_regs + mmDISP_DB_BUF_CNTL);
+}
+
+static void w100_update_enable(void)
+{
+        union disp_db_buf_cntl_wr_u disp_db_buf_wr_cntl;
+
+        /* Enable display updates */
+        disp_db_buf_wr_cntl.f.db_buf_cntl = 0x1e;
+        disp_db_buf_wr_cntl.f.update_db_buf = 1;
+        disp_db_buf_wr_cntl.f.en_db_buf = 1;
+        writel((u32) (disp_db_buf_wr_cntl.val), remapped_regs + mmDISP_DB_BUF_CNTL);
+}
+
+unsigned long w100fb_gpio_read(int port)
+{
+        unsigned long value;
+
+        if (port==W100_GPIO_PORT_A)
+                value = readl(remapped_regs + mmGPIO_DATA);
+        else
+                value = readl(remapped_regs + mmGPIO_DATA2);
+
+        return value;
+}
+
+void w100fb_gpio_write(int port, unsigned long value)
+{
+        if (port==W100_GPIO_PORT_A)
+                value = writel(value, remapped_regs + mmGPIO_DATA);
+        else
+                value = writel(value, remapped_regs + mmGPIO_DATA2);
+}
+EXPORT_SYMBOL(w100fb_gpio_read);
+EXPORT_SYMBOL(w100fb_gpio_write);
+
 /*
  * Initialization of critical w100 hardware
  */
-static void w100_hw_init(void)
+static void w100_hw_init(struct w100fb_par *par)
 {
         u32 temp32;
         union cif_cntl_u cif_cntl;
@@ -735,8 +722,8 @@ static void w100_hw_init(void)
         union cpu_defaults_u cpu_default;
         union cif_write_dbg_u cif_write_dbg;
         union wrap_start_dir_u wrap_start_dir;
-        union mc_ext_mem_location_u mc_ext_mem_loc;
         union cif_io_u cif_io;
+        struct w100_gpio_regs *gpio = par->mach->gpio;
 
         w100_soft_reset();
 
@@ -791,19 +778,6 @@ static void w100_hw_init(void)
         cfgreg_base.f.cfgreg_base = W100_CFG_BASE;
         writel((u32) (cfgreg_base.val), remapped_regs + mmCFGREG_BASE);
 
-        /* This location is relative to internal w100 addresses */
-        writel(0x15FF1000, remapped_regs + mmMC_FB_LOCATION);
-
-        mc_ext_mem_loc.val = defMC_EXT_MEM_LOCATION;
-        mc_ext_mem_loc.f.mc_ext_mem_start = MEM_EXT_BASE_VALUE >> 8;
-        mc_ext_mem_loc.f.mc_ext_mem_top = MEM_EXT_TOP_VALUE >> 8;
-        writel((u32) (mc_ext_mem_loc.val), remapped_regs + mmMC_EXT_MEM_LOCATION);
-
-        if ((current_par->lcdMode == LCD_MODE_240) || (current_par->lcdMode == LCD_MODE_320))
-                w100_InitExtMem(LCD_SHARP_QVGA);
-        else
-                w100_InitExtMem(LCD_SHARP_VGA);
-
         wrap_start_dir.val = defWRAP_START_DIR;
         wrap_start_dir.f.start_addr = WRAP_BUF_BASE_VALUE >> 1;
         writel((u32) (wrap_start_dir.val), remapped_regs + mmWRAP_START_DIR);
@@ -813,21 +787,24 @@ static void w100_hw_init(void)
         writel((u32) (wrap_top_dir.val), remapped_regs + mmWRAP_TOP_DIR);
 
         writel((u32) 0x2440, remapped_regs + mmRBBM_CNTL);
-}
 
+        /* Set the hardware to 565 colour */
+        temp32 = readl(remapped_regs + mmDISP_DEBUG2);
+        temp32 &= 0xff7fffff;
+        temp32 |= 0x00800000;
+        writel(temp32, remapped_regs + mmDISP_DEBUG2);
 
-/*
- * Types
- */
+        /* Initialise the GPIO lines */
+        if (gpio) {
+                writel(gpio->init_data1, remapped_regs + mmGPIO_DATA);
+                writel(gpio->init_data2, remapped_regs + mmGPIO_DATA2);
+                writel(gpio->gpio_dir1,  remapped_regs + mmGPIO_CNTL1);
+                writel(gpio->gpio_oe1,   remapped_regs + mmGPIO_CNTL2);
+                writel(gpio->gpio_dir2,  remapped_regs + mmGPIO_CNTL3);
+                writel(gpio->gpio_oe2,   remapped_regs + mmGPIO_CNTL4);
+        }
+}
 
-struct pll_parm {
-        u16 freq;               /* desired Fout for PLL */
-        u8 M;
-        u8 N_int;
-        u8 N_fac;
-        u8 tfgoal;
-        u8 lock_time;
-};
 
 struct power_state {
         union clk_pin_cntl_u clk_pin_cntl;
@@ -835,317 +812,275 @@ struct power_state {
         union pll_cntl_u pll_cntl;
         union sclk_cntl_u sclk_cntl;
         union pclk_cntl_u pclk_cntl;
-        union clk_test_cntl_u clk_test_cntl;
         union pwrmgt_cntl_u pwrmgt_cntl;
-        u32 freq;               /* Fout for PLL calibration */
-        u8 tf100;               /* for pll calibration */
-        u8 tf80;                /* for pll calibration */
-        u8 tf20;                /* for pll calibration */
-        u8 M;                   /* for pll calibration */
-        u8 N_int;               /* for pll calibration */
-        u8 N_fac;               /* for pll calibration */
-        u8 lock_time;   /* for pll calibration */
-        u8 tfgoal;              /* for pll calibration */
-        u8 auto_mode;   /* hardware auto switch? */
-        u8 pwm_mode;            /* 0 fast, 1 normal/slow */
-        u16 fast_sclk;  /* fast clk freq */
-        u16 norm_sclk;  /* slow clk freq */
+        int auto_mode;  /* system clock auto changing? */
 };
 
 
-/*
- * Global state variables
- */
-
 static struct power_state w100_pwr_state;
 
-/* This table is specific for 12.5MHz ref crystal.  */
-static struct pll_parm gPLLTable[] = {
-    /*freq     M   N_int    N_fac  tfgoal  lock_time */
-    { 50,      0,   1,       0,     0xE0,        56}, /*  50.00 MHz */
-    { 75,      0,   5,       0,     0xDE,            37}, /*  75.00 MHz */
-    {100,      0,   7,       0,     0xE0,        28}, /* 100.00 MHz */
-    {125,      0,   9,       0,     0xE0,        22}, /* 125.00 MHz */
-    {150,      0,   11,      0,     0xE0,        17}, /* 150.00 MHz */
-    {  0,      0,   0,       0,        0,         0}  /* Terminator */
+/* The PLL Fout is determined by (XtalFreq/(M+1)) * ((N_int+1) + (N_fac/8)) */
+
+/* 12.5MHz Crystal PLL Table */
+static struct w100_pll_info xtal_12500000[] = {
+        /*freq     M   N_int    N_fac  tfgoal  lock_time */
+        { 50,      0,   1,       0,     0xe0,        56},  /*  50.00 MHz */
+        { 75,      0,   5,       0,     0xde,        37},  /*  75.00 MHz */
+        {100,      0,   7,       0,     0xe0,        28},  /* 100.00 MHz */
+        {125,      0,   9,       0,     0xe0,        22},  /* 125.00 MHz */
+        {150,      0,   11,      0,     0xe0,        17},  /* 150.00 MHz */
+        {  0,      0,   0,       0,        0,         0},  /* Terminator */
 };
 
+/* 14.318MHz Crystal PLL Table */
+static struct w100_pll_info xtal_14318000[] = {
+        /*freq     M   N_int    N_fac  tfgoal  lock_time */
+        { 40,      4,   13,      0,     0xe0,        80}, /* tfgoal guessed */
+        { 50,      1,   6,       0,     0xe0,        64}, /*  50.05 MHz */
+        { 57,      2,   11,      0,     0xe0,        53}, /* tfgoal guessed */
+        { 75,      0,   4,       3,     0xe0,        43}, /*  75.08 MHz */
+        {100,      0,   6,       0,     0xe0,        32}, /* 100.10 MHz */
+        {  0,      0,   0,       0,        0,         0},
+};
 
-static u8 w100_pll_get_testcount(u8 testclk_sel)
+/* 16MHz Crystal PLL Table */
+static struct w100_pll_info xtal_16000000[] = {
+        /*freq     M   N_int    N_fac  tfgoal  lock_time */
+        { 72,      1,   8,       0,     0xe0,        48}, /* tfgoal guessed */
+        { 95,      1,   10,      7,     0xe0,        38}, /* tfgoal guessed */
+        { 96,      1,   11,      0,     0xe0,        36}, /* tfgoal guessed */
+        {  0,      0,   0,       0,        0,         0},
+};
+
+static struct pll_entries {
+        int xtal_freq;
+        struct w100_pll_info *pll_table;
+} w100_pll_tables[] = {
+        { 12500000, &xtal_12500000[0] },
+        { 14318000, &xtal_14318000[0] },
+        { 16000000, &xtal_16000000[0] },
+        { 0 },
+};
+
+struct w100_pll_info *w100_get_xtal_table(unsigned int freq)
 {
+        struct pll_entries *pll_entry = w100_pll_tables;
+
+        do {
+                if (freq == pll_entry->xtal_freq)
+                        return pll_entry->pll_table;
+                pll_entry++;
+        } while (pll_entry->xtal_freq);
+        return 0;
+}
+
+
+static unsigned int w100_get_testcount(unsigned int testclk_sel)
+{
+        union clk_test_cntl_u clk_test_cntl;
+
         udelay(5);
 
-        w100_pwr_state.clk_test_cntl.f.start_check_freq = 0x0;
-        w100_pwr_state.clk_test_cntl.f.testclk_sel = testclk_sel;
-        w100_pwr_state.clk_test_cntl.f.tstcount_rst = 0x1;      /*reset test count */
-        writel((u32) (w100_pwr_state.clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
-        w100_pwr_state.clk_test_cntl.f.tstcount_rst = 0x0;
-        writel((u32) (w100_pwr_state.clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
+        /* Select the test clock source and reset */
+        clk_test_cntl.f.start_check_freq = 0x0;
+        clk_test_cntl.f.testclk_sel = testclk_sel;
+        clk_test_cntl.f.tstcount_rst = 0x1; /* set reset */
+        writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
 
-        w100_pwr_state.clk_test_cntl.f.start_check_freq = 0x1;
-        writel((u32) (w100_pwr_state.clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
+        clk_test_cntl.f.tstcount_rst = 0x0; /* clear reset */
+        writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
 
+        /* Run clock test */
+        clk_test_cntl.f.start_check_freq = 0x1;
+        writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
+
+        /* Give the test time to complete */
         udelay(20);
 
-        w100_pwr_state.clk_test_cntl.val = readl(remapped_regs + mmCLK_TEST_CNTL);
-        w100_pwr_state.clk_test_cntl.f.start_check_freq = 0x0;
-        writel((u32) (w100_pwr_state.clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
+        /* Return the result */
+        clk_test_cntl.val = readl(remapped_regs + mmCLK_TEST_CNTL);
+        clk_test_cntl.f.start_check_freq = 0x0;
+        writel((u32) (clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
 
-        return w100_pwr_state.clk_test_cntl.f.test_count;
+        return clk_test_cntl.f.test_count;
 }
 
 
-static u8 w100_pll_adjust(void)
+static int w100_pll_adjust(struct w100_pll_info *pll)
 {
+        unsigned int tf80;
+        unsigned int tf20;
+
+        /* Initial Settings */
+        w100_pwr_state.pll_cntl.f.pll_pwdn = 0x0;     /* power down */
+        w100_pwr_state.pll_cntl.f.pll_reset = 0x0;    /* not reset */
+        w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x1;   /* Hi-Z */
+        w100_pwr_state.pll_cntl.f.pll_pvg = 0x0;      /* VCO gain = 0 */
+        w100_pwr_state.pll_cntl.f.pll_vcofr = 0x0;    /* VCO frequency range control = off */
+        w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;  /* current offset inside VCO = 0 */
+        w100_pwr_state.pll_cntl.f.pll_ring_off = 0x0;
+
+        /* Wai Ming 80 percent of VDD 1.3V gives 1.04V, minimum operating voltage is 1.08V
+         * therefore, commented out the following lines
+         * tf80 meant tf100
+         */
         do {
-                /* Wai Ming 80 percent of VDD 1.3V gives 1.04V, minimum operating voltage is 1.08V
-                 * therefore, commented out the following lines
-                 * tf80 meant tf100
-                 * set VCO input = 0.8 * VDD
-                 */
+                /* set VCO input = 0.8 * VDD */
                 w100_pwr_state.pll_cntl.f.pll_dactal = 0xd;
                 writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
 
-                w100_pwr_state.tf80 = w100_pll_get_testcount(0x1);      /* PLLCLK */
-                if (w100_pwr_state.tf80 >= (w100_pwr_state.tfgoal)) {
+                tf80 = w100_get_testcount(TESTCLK_SRC_PLL);
+                if (tf80 >= (pll->tfgoal)) {
                         /* set VCO input = 0.2 * VDD */
                         w100_pwr_state.pll_cntl.f.pll_dactal = 0x7;
                         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
 
-                        w100_pwr_state.tf20 = w100_pll_get_testcount(0x1);      /* PLLCLK */
-                        if (w100_pwr_state.tf20 <= (w100_pwr_state.tfgoal))
-                                return 1; // Success
+                        tf20 = w100_get_testcount(TESTCLK_SRC_PLL);
+                        if (tf20 <= (pll->tfgoal))
+                                return 1;  /* Success */
 
                         if ((w100_pwr_state.pll_cntl.f.pll_vcofr == 0x0) &&
-                            ((w100_pwr_state.pll_cntl.f.pll_pvg == 0x7) ||
-                             (w100_pwr_state.pll_cntl.f.pll_ioffset == 0x0))) {
+                                ((w100_pwr_state.pll_cntl.f.pll_pvg == 0x7) ||
+                                (w100_pwr_state.pll_cntl.f.pll_ioffset == 0x0))) {
                                 /* slow VCO config */
                                 w100_pwr_state.pll_cntl.f.pll_vcofr = 0x1;
                                 w100_pwr_state.pll_cntl.f.pll_pvg = 0x0;
                                 w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;
-                                writel((u32) (w100_pwr_state.pll_cntl.val),
-                                        remapped_regs + mmPLL_CNTL);
                                 continue;
                         }
                 }
                 if ((w100_pwr_state.pll_cntl.f.pll_ioffset) < 0x3) {
                         w100_pwr_state.pll_cntl.f.pll_ioffset += 0x1;
-                        writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
-                        continue;
-                }
-                if ((w100_pwr_state.pll_cntl.f.pll_pvg) < 0x7) {
+                } else if ((w100_pwr_state.pll_cntl.f.pll_pvg) < 0x7) {
                         w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;
                         w100_pwr_state.pll_cntl.f.pll_pvg += 0x1;
-                        writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
-                        continue;
+                } else {
+                        return 0;  /* Error */
                 }
-                return 0; // error
         } while(1);
 }
 
 
 /*
  * w100_pll_calibration
- *                freq = target frequency of the PLL
- *                (note: crystal = 14.3MHz)
  */
-static u8 w100_pll_calibration(u32 freq)
+static int w100_pll_calibration(struct w100_pll_info *pll)
 {
-        u8 status;
-
-        /* initial setting */
-        w100_pwr_state.pll_cntl.f.pll_pwdn = 0x0;               /* power down */
-        w100_pwr_state.pll_cntl.f.pll_reset = 0x0;              /* not reset */
-        w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x1;     /* Hi-Z */
-        w100_pwr_state.pll_cntl.f.pll_pvg = 0x0;                /* VCO gain = 0 */
-        w100_pwr_state.pll_cntl.f.pll_vcofr = 0x0;              /* VCO frequency range control = off */
-        w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;    /* current offset inside VCO = 0 */
-        w100_pwr_state.pll_cntl.f.pll_ring_off = 0x0;
-        writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
+        int status;
 
-        /* check for (tf80 >= tfgoal) && (tf20 =< tfgoal) */
-        if ((w100_pwr_state.tf80 < w100_pwr_state.tfgoal) || (w100_pwr_state.tf20 > w100_pwr_state.tfgoal)) {
-                status=w100_pll_adjust();
-        }
-        /* PLL Reset And Lock */
+        status = w100_pll_adjust(pll);
 
+        /* PLL Reset And Lock */
         /* set VCO input = 0.5 * VDD */
         w100_pwr_state.pll_cntl.f.pll_dactal = 0xa;
         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
 
-        /* reset time */
-        udelay(1);
+        udelay(1);  /* reset time */
 
         /* enable charge pump */
-        w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x0;     /* normal */
+        w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x0;  /* normal */
         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
 
-        /* set VCO input = Hi-Z */
-        /* disable DAC */
+        /* set VCO input = Hi-Z, disable DAC */
         w100_pwr_state.pll_cntl.f.pll_dactal = 0x0;
         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
 
-        /* lock time */
-        udelay(400);    /* delay 400 us */
+        udelay(400);  /* lock time */
 
         /* PLL locked */
 
-        w100_pwr_state.sclk_cntl.f.sclk_src_sel = 0x1;  /* PLL clock */
-        writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
-
-        w100_pwr_state.tf100 = w100_pll_get_testcount(0x1);     /* PLLCLK */
-
         return status;
 }
 
 
-static u8 w100_pll_set_clk(void)
+static int w100_pll_set_clk(struct w100_pll_info *pll)
 {
-        u8 status;
+        int status;
 
-        if (w100_pwr_state.auto_mode == 1)      /* auto mode */
+        if (w100_pwr_state.auto_mode == 1)  /* auto mode */
         {
-                w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x0; /* disable fast to normal */
-                w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x0; /* disable normal to fast */
+                w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x0;  /* disable fast to normal */
+                w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x0;  /* disable normal to fast */
                 writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
         }
 
-        w100_pwr_state.sclk_cntl.f.sclk_src_sel = 0x0;  /* crystal clock */
+        /* Set system clock source to XTAL whilst adjusting the PLL! */
+        w100_pwr_state.sclk_cntl.f.sclk_src_sel = CLK_SRC_XTAL;
         writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
 
-        w100_pwr_state.pll_ref_fb_div.f.pll_ref_div = w100_pwr_state.M;
-        w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_int = w100_pwr_state.N_int;
-        w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_frac = w100_pwr_state.N_fac;
-        w100_pwr_state.pll_ref_fb_div.f.pll_lock_time = w100_pwr_state.lock_time;
+        w100_pwr_state.pll_ref_fb_div.f.pll_ref_div = pll->M;
+        w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_int = pll->N_int;
+        w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_frac = pll->N_fac;
+        w100_pwr_state.pll_ref_fb_div.f.pll_lock_time = pll->lock_time;
         writel((u32) (w100_pwr_state.pll_ref_fb_div.val), remapped_regs + mmPLL_REF_FB_DIV);
 
         w100_pwr_state.pwrmgt_cntl.f.pwm_mode_req = 0;
         writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
 
-        status = w100_pll_calibration (w100_pwr_state.freq);
+        status = w100_pll_calibration(pll);
 
-        if (w100_pwr_state.auto_mode == 1)      /* auto mode */
+        if (w100_pwr_state.auto_mode == 1)  /* auto mode */
         {
-                w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x1; /* reenable fast to normal */
-                w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x1; /* reenable normal to fast  */
+                w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x1;  /* reenable fast to normal */
+                w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x1;  /* reenable normal to fast  */
                 writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
         }
         return status;
 }
 
-
-/* assume reference crystal clk is 12.5MHz,
- * and that doubling is not enabled.
- *
- * Freq = 12 == 12.5MHz.
- */
-static u16 w100_set_slowsysclk(u16 freq)
-{
-        if (w100_pwr_state.norm_sclk == freq)
-                return freq;
-
-        if (w100_pwr_state.auto_mode == 1)      /* auto mode */
-                return 0;
-
-        if (freq == 12) {
-                w100_pwr_state.norm_sclk = freq;
-                w100_pwr_state.sclk_cntl.f.sclk_post_div_slow = 0x0;    /* Pslow = 1 */
-                w100_pwr_state.sclk_cntl.f.sclk_src_sel = 0x0;  /* crystal src */
-
-                writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
-
-                w100_pwr_state.clk_pin_cntl.f.xtalin_pm_en = 0x1;
-                writel((u32) (w100_pwr_state.clk_pin_cntl.val), remapped_regs + mmCLK_PIN_CNTL);
-
-                w100_pwr_state.pwrmgt_cntl.f.pwm_enable = 0x1;
-                w100_pwr_state.pwrmgt_cntl.f.pwm_mode_req = 0x1;
-                writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
-                w100_pwr_state.pwm_mode = 1;    /* normal mode */
-                return freq;
-        } else
-                return 0;
-}
-
-
-static u16 w100_set_fastsysclk(u16 freq)
+/* freq = target frequency of the PLL */
+static int w100_set_pll_freq(struct w100fb_par *par, unsigned int freq)
 {
-        u16 pll_freq;
-        int i;
-
-        while(1) {
-                pll_freq = (u16) (freq * (w100_pwr_state.sclk_cntl.f.sclk_post_div_fast + 1));
-                i = 0;
-                do {
-                        if (pll_freq == gPLLTable[i].freq) {
-                                w100_pwr_state.freq = gPLLTable[i].freq * 1000000;
-                                w100_pwr_state.M = gPLLTable[i].M;
-                                w100_pwr_state.N_int = gPLLTable[i].N_int;
-                                w100_pwr_state.N_fac = gPLLTable[i].N_fac;
-                                w100_pwr_state.tfgoal = gPLLTable[i].tfgoal;
-                                w100_pwr_state.lock_time = gPLLTable[i].lock_time;
-                                w100_pwr_state.tf20 = 0xff;     /* set highest */
-                                w100_pwr_state.tf80 = 0x00;     /* set lowest */
-
-                                w100_pll_set_clk();
-                                w100_pwr_state.pwm_mode = 0;    /* fast mode */
-                                w100_pwr_state.fast_sclk = freq;
-                                return freq;
-                        }
-                        i++;
-                } while(gPLLTable[i].freq);
+        struct w100_pll_info *pll = par->pll_table;
 
-                if (w100_pwr_state.auto_mode == 1)
-                        break;
-
-                if (w100_pwr_state.sclk_cntl.f.sclk_post_div_fast == 0)
-                        break;
-
-                w100_pwr_state.sclk_cntl.f.sclk_post_div_fast -= 1;
-                writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
-        }
+        do {
+                if (freq == pll->freq) {
+                        return w100_pll_set_clk(pll);
+                }
+                pll++;
+        } while(pll->freq);
         return 0;
 }
 
-
 /* Set up an initial state.  Some values/fields set
    here will be overwritten. */
-static void w100_pwm_setup(void)
+static void w100_pwm_setup(struct w100fb_par *par)
 {
         w100_pwr_state.clk_pin_cntl.f.osc_en = 0x1;
         w100_pwr_state.clk_pin_cntl.f.osc_gain = 0x1f;
         w100_pwr_state.clk_pin_cntl.f.dont_use_xtalin = 0x0;
         w100_pwr_state.clk_pin_cntl.f.xtalin_pm_en = 0x0;
-        w100_pwr_state.clk_pin_cntl.f.xtalin_dbl_en = 0x0;      /* no freq doubling */
+        w100_pwr_state.clk_pin_cntl.f.xtalin_dbl_en = par->mach->xtal_dbl ? 1 : 0;
         w100_pwr_state.clk_pin_cntl.f.cg_debug = 0x0;
         writel((u32) (w100_pwr_state.clk_pin_cntl.val), remapped_regs + mmCLK_PIN_CNTL);
 
-        w100_pwr_state.sclk_cntl.f.sclk_src_sel = 0x0;  /* Crystal Clk */
-        w100_pwr_state.sclk_cntl.f.sclk_post_div_fast = 0x0;    /* Pfast = 1 */
+        w100_pwr_state.sclk_cntl.f.sclk_src_sel = CLK_SRC_XTAL;
+        w100_pwr_state.sclk_cntl.f.sclk_post_div_fast = 0x0;  /* Pfast = 1 */
         w100_pwr_state.sclk_cntl.f.sclk_clkon_hys = 0x3;
-        w100_pwr_state.sclk_cntl.f.sclk_post_div_slow = 0x0;    /* Pslow = 1 */
+        w100_pwr_state.sclk_cntl.f.sclk_post_div_slow = 0x0;  /* Pslow = 1 */
         w100_pwr_state.sclk_cntl.f.disp_cg_ok2switch_en = 0x0;
-        w100_pwr_state.sclk_cntl.f.sclk_force_reg = 0x0;        /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_disp = 0x0;       /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_mc = 0x0; /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_extmc = 0x0;      /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_cp = 0x0; /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_e2 = 0x0; /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_e3 = 0x0; /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_idct = 0x0;       /* Dynamic */
-        w100_pwr_state.sclk_cntl.f.sclk_force_bist = 0x0;       /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_reg = 0x0;    /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_disp = 0x0;   /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_mc = 0x0;     /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_extmc = 0x0;  /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_cp = 0x0;     /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_e2 = 0x0;     /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_e3 = 0x0;     /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_idct = 0x0;   /* Dynamic */
+        w100_pwr_state.sclk_cntl.f.sclk_force_bist = 0x0;   /* Dynamic */
         w100_pwr_state.sclk_cntl.f.busy_extend_cp = 0x0;
         w100_pwr_state.sclk_cntl.f.busy_extend_e2 = 0x0;
         w100_pwr_state.sclk_cntl.f.busy_extend_e3 = 0x0;
         w100_pwr_state.sclk_cntl.f.busy_extend_idct = 0x0;
         writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
 
-        w100_pwr_state.pclk_cntl.f.pclk_src_sel = 0x0;  /* Crystal Clk */
-        w100_pwr_state.pclk_cntl.f.pclk_post_div = 0x1; /* P = 2 */
-        w100_pwr_state.pclk_cntl.f.pclk_force_disp = 0x0;       /* Dynamic */
+        w100_pwr_state.pclk_cntl.f.pclk_src_sel = CLK_SRC_XTAL;
+        w100_pwr_state.pclk_cntl.f.pclk_post_div = 0x1;    /* P = 2 */
+        w100_pwr_state.pclk_cntl.f.pclk_force_disp = 0x0;  /* Dynamic */
         writel((u32) (w100_pwr_state.pclk_cntl.val), remapped_regs + mmPCLK_CNTL);
 
-        w100_pwr_state.pll_ref_fb_div.f.pll_ref_div = 0x0;      /* M = 1 */
-        w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_int = 0x0;   /* N = 1.0 */
+        w100_pwr_state.pll_ref_fb_div.f.pll_ref_div = 0x0;     /* M = 1 */
+        w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_int = 0x0;  /* N = 1.0 */
         w100_pwr_state.pll_ref_fb_div.f.pll_fb_div_frac = 0x0;
         w100_pwr_state.pll_ref_fb_div.f.pll_reset_time = 0x5;
         w100_pwr_state.pll_ref_fb_div.f.pll_lock_time = 0xff;
@@ -1154,7 +1089,7 @@ static void w100_pwm_setup(void)
         w100_pwr_state.pll_cntl.f.pll_pwdn = 0x1;
         w100_pwr_state.pll_cntl.f.pll_reset = 0x1;
         w100_pwr_state.pll_cntl.f.pll_pm_en = 0x0;
-        w100_pwr_state.pll_cntl.f.pll_mode = 0x0;       /* uses VCO clock */
+        w100_pwr_state.pll_cntl.f.pll_mode = 0x0;  /* uses VCO clock */
         w100_pwr_state.pll_cntl.f.pll_refclk_sel = 0x0;
         w100_pwr_state.pll_cntl.f.pll_fbclk_sel = 0x0;
         w100_pwr_state.pll_cntl.f.pll_tcpoff = 0x0;
@@ -1164,220 +1099,275 @@ static void w100_pwm_setup(void)
         w100_pwr_state.pll_cntl.f.pll_ioffset = 0x0;
         w100_pwr_state.pll_cntl.f.pll_pecc_mode = 0x0;
         w100_pwr_state.pll_cntl.f.pll_pecc_scon = 0x0;
-        w100_pwr_state.pll_cntl.f.pll_dactal = 0x0;     /* Hi-Z */
+        w100_pwr_state.pll_cntl.f.pll_dactal = 0x0;  /* Hi-Z */
         w100_pwr_state.pll_cntl.f.pll_cp_clip = 0x3;
         w100_pwr_state.pll_cntl.f.pll_conf = 0x2;
         w100_pwr_state.pll_cntl.f.pll_mbctrl = 0x2;
         w100_pwr_state.pll_cntl.f.pll_ring_off = 0x0;
         writel((u32) (w100_pwr_state.pll_cntl.val), remapped_regs + mmPLL_CNTL);
 
-        w100_pwr_state.clk_test_cntl.f.testclk_sel = 0x1;       /* PLLCLK (for testing) */
-        w100_pwr_state.clk_test_cntl.f.start_check_freq = 0x0;
-        w100_pwr_state.clk_test_cntl.f.tstcount_rst = 0x0;
-        writel((u32) (w100_pwr_state.clk_test_cntl.val), remapped_regs + mmCLK_TEST_CNTL);
-
         w100_pwr_state.pwrmgt_cntl.f.pwm_enable = 0x0;
-        w100_pwr_state.pwrmgt_cntl.f.pwm_mode_req = 0x1;        /* normal mode (0, 1, 3) */
+        w100_pwr_state.pwrmgt_cntl.f.pwm_mode_req = 0x1;  /* normal mode (0, 1, 3) */
         w100_pwr_state.pwrmgt_cntl.f.pwm_wakeup_cond = 0x0;
         w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_hw_en = 0x0;
         w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_hw_en = 0x0;
-        w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_cond = 0x1;  /* PM4,ENG */
-        w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_cond = 0x1;  /* PM4,ENG */
+        w100_pwr_state.pwrmgt_cntl.f.pwm_fast_noml_cond = 0x1;  /* PM4,ENG */
+        w100_pwr_state.pwrmgt_cntl.f.pwm_noml_fast_cond = 0x1;  /* PM4,ENG */
         w100_pwr_state.pwrmgt_cntl.f.pwm_idle_timer = 0xFF;
         w100_pwr_state.pwrmgt_cntl.f.pwm_busy_timer = 0xFF;
         writel((u32) (w100_pwr_state.pwrmgt_cntl.val), remapped_regs + mmPWRMGT_CNTL);
 
-        w100_pwr_state.auto_mode = 0;   /* manual mode */
-        w100_pwr_state.pwm_mode = 1;    /* normal mode (0, 1, 2) */
-        w100_pwr_state.freq = 50000000; /* 50 MHz */
-        w100_pwr_state.M = 3;   /* M = 4 */
-        w100_pwr_state.N_int = 6;       /* N = 7.0 */
-        w100_pwr_state.N_fac = 0;
-        w100_pwr_state.tfgoal = 0xE0;
-        w100_pwr_state.lock_time = 56;
-        w100_pwr_state.tf20 = 0xff;     /* set highest */
-        w100_pwr_state.tf80 = 0x00;     /* set lowest */
-        w100_pwr_state.tf100 = 0x00;    /* set lowest */
-        w100_pwr_state.fast_sclk = 50;  /* 50.0 MHz */
-        w100_pwr_state.norm_sclk = 12;  /* 12.5 MHz */
+        w100_pwr_state.auto_mode = 0;  /* manual mode */
 }
 
 
-static void w100_init_sharp_lcd(u32 mode)
+/*
+ * Setup the w100 clocks for the specified mode
+ */
+static void w100_init_clocks(struct w100fb_par *par)
 {
-        u32 temp32;
-        union disp_db_buf_cntl_wr_u disp_db_buf_wr_cntl;
+        struct w100_mode *mode = par->mode;
 
-        /* Prevent display updates */
-        disp_db_buf_wr_cntl.f.db_buf_cntl = 0x1e;
-        disp_db_buf_wr_cntl.f.update_db_buf = 0;
-        disp_db_buf_wr_cntl.f.en_db_buf = 0;
-        writel((u32) (disp_db_buf_wr_cntl.val), remapped_regs + mmDISP_DB_BUF_CNTL);
+        if (mode->pixclk_src == CLK_SRC_PLL || mode->sysclk_src == CLK_SRC_PLL)
+                w100_set_pll_freq(par, (par->fastpll_mode && mode->fast_pll_freq) ? mode->fast_pll_freq : mode->pll_freq);
 
-        switch(mode) {
-        case LCD_SHARP_QVGA:
-                w100_set_slowsysclk(12);        /* use crystal -- 12.5MHz */
-                /* not use PLL */
-
-                writel(0x7FFF8000, remapped_regs + mmMC_EXT_MEM_LOCATION);
-                writel(0x85FF8000, remapped_regs + mmMC_FB_LOCATION);
-                writel(0x00000003, remapped_regs + mmLCD_FORMAT);
-                writel(0x00CF1C06, remapped_regs + mmGRAPHIC_CTRL);
-                writel(0x01410145, remapped_regs + mmCRTC_TOTAL);
-                writel(0x01170027, remapped_regs + mmACTIVE_H_DISP);
-                writel(0x01410001, remapped_regs + mmACTIVE_V_DISP);
-                writel(0x01170027, remapped_regs + mmGRAPHIC_H_DISP);
-                writel(0x01410001, remapped_regs + mmGRAPHIC_V_DISP);
-                writel(0x81170027, remapped_regs + mmCRTC_SS);
-                writel(0xA0140000, remapped_regs + mmCRTC_LS);
-                writel(0x00400008, remapped_regs + mmCRTC_REV);
-                writel(0xA0000000, remapped_regs + mmCRTC_DCLK);
-                writel(0xC0140014, remapped_regs + mmCRTC_GS);
-                writel(0x00010141, remapped_regs + mmCRTC_VPOS_GS);
-                writel(0x8015010F, remapped_regs + mmCRTC_GCLK);
-                writel(0x80100110, remapped_regs + mmCRTC_GOE);
-                writel(0x00000000, remapped_regs + mmCRTC_FRAME);
-                writel(0x00000000, remapped_regs + mmCRTC_FRAME_VPOS);
-                writel(0x01CC0000, remapped_regs + mmLCDD_CNTL1);
-                writel(0x0003FFFF, remapped_regs + mmLCDD_CNTL2);
-                writel(0x00FFFF0D, remapped_regs + mmGENLCD_CNTL1);
-                writel(0x003F3003, remapped_regs + mmGENLCD_CNTL2);
-                writel(0x00000000, remapped_regs + mmCRTC_DEFAULT_COUNT);
-                writel(0x0000FF00, remapped_regs + mmLCD_BACKGROUND_COLOR);
-                writel(0x000102aa, remapped_regs + mmGENLCD_CNTL3);
-                writel(0x00800000, remapped_regs + mmGRAPHIC_OFFSET);
-                writel(0x000001e0, remapped_regs + mmGRAPHIC_PITCH);
-                writel(0x000000bf, remapped_regs + mmGPIO_DATA);
-                writel(0x03c0feff, remapped_regs + mmGPIO_CNTL2);
-                writel(0x00000000, remapped_regs + mmGPIO_CNTL1);
-                writel(0x41060010, remapped_regs + mmCRTC_PS1_ACTIVE);
-                break;
-        case LCD_SHARP_VGA:
-                w100_set_slowsysclk(12);        /* use crystal -- 12.5MHz */
-                w100_set_fastsysclk(current_par->fastsysclk_mode);      /* use PLL -- 75.0MHz */
-                w100_pwr_state.pclk_cntl.f.pclk_src_sel = 0x1;
-                w100_pwr_state.pclk_cntl.f.pclk_post_div = 0x2;
-                writel((u32) (w100_pwr_state.pclk_cntl.val), remapped_regs + mmPCLK_CNTL);
-                writel(0x15FF1000, remapped_regs + mmMC_FB_LOCATION);
-                writel(0x9FFF8000, remapped_regs + mmMC_EXT_MEM_LOCATION);
-                writel(0x00000003, remapped_regs + mmLCD_FORMAT);
-                writel(0x00DE1D66, remapped_regs + mmGRAPHIC_CTRL);
-
-                writel(0x0283028B, remapped_regs + mmCRTC_TOTAL);
-                writel(0x02360056, remapped_regs + mmACTIVE_H_DISP);
-                writel(0x02830003, remapped_regs + mmACTIVE_V_DISP);
-                writel(0x02360056, remapped_regs + mmGRAPHIC_H_DISP);
-                writel(0x02830003, remapped_regs + mmGRAPHIC_V_DISP);
-                writel(0x82360056, remapped_regs + mmCRTC_SS);
-                writel(0xA0280000, remapped_regs + mmCRTC_LS);
-                writel(0x00400008, remapped_regs + mmCRTC_REV);
-                writel(0xA0000000, remapped_regs + mmCRTC_DCLK);
-                writel(0x80280028, remapped_regs + mmCRTC_GS);
-                writel(0x02830002, remapped_regs + mmCRTC_VPOS_GS);
-                writel(0x8015010F, remapped_regs + mmCRTC_GCLK);
-                writel(0x80100110, remapped_regs + mmCRTC_GOE);
-                writel(0x00000000, remapped_regs + mmCRTC_FRAME);
-                writel(0x00000000, remapped_regs + mmCRTC_FRAME_VPOS);
-                writel(0x01CC0000, remapped_regs + mmLCDD_CNTL1);
-                writel(0x0003FFFF, remapped_regs + mmLCDD_CNTL2);
-                writel(0x00FFFF0D, remapped_regs + mmGENLCD_CNTL1);
-                writel(0x003F3003, remapped_regs + mmGENLCD_CNTL2);
-                writel(0x00000000, remapped_regs + mmCRTC_DEFAULT_COUNT);
-                writel(0x0000FF00, remapped_regs + mmLCD_BACKGROUND_COLOR);
-                writel(0x000102aa, remapped_regs + mmGENLCD_CNTL3);
-                writel(0x00800000, remapped_regs + mmGRAPHIC_OFFSET);
-                writel(0x000003C0, remapped_regs + mmGRAPHIC_PITCH);
-                writel(0x000000bf, remapped_regs + mmGPIO_DATA);
-                writel(0x03c0feff, remapped_regs + mmGPIO_CNTL2);
-                writel(0x00000000, remapped_regs + mmGPIO_CNTL1);
-                writel(0x41060010, remapped_regs + mmCRTC_PS1_ACTIVE);
-                break;
-        default:
-                break;
-        }
+        w100_pwr_state.sclk_cntl.f.sclk_src_sel = mode->sysclk_src;
+        w100_pwr_state.sclk_cntl.f.sclk_post_div_fast = mode->sysclk_divider;
+        w100_pwr_state.sclk_cntl.f.sclk_post_div_slow = mode->sysclk_divider;
+        writel((u32) (w100_pwr_state.sclk_cntl.val), remapped_regs + mmSCLK_CNTL);
+}
+
+static void w100_init_lcd(struct w100fb_par *par)
+{
+        u32 temp32;
+        struct w100_mode *mode = par->mode;
+        struct w100_gen_regs *regs = par->mach->regs;
+        union active_h_disp_u active_h_disp;
+        union active_v_disp_u active_v_disp;
+        union graphic_h_disp_u graphic_h_disp;
+        union graphic_v_disp_u graphic_v_disp;
+        union crtc_total_u crtc_total;
+
+        /* w3200 doesnt like undefined bits being set so zero register values first */
+
+        active_h_disp.val = 0;
+        active_h_disp.f.active_h_start=mode->left_margin;
+        active_h_disp.f.active_h_end=mode->left_margin + mode->xres;
+        writel(active_h_disp.val, remapped_regs + mmACTIVE_H_DISP);
+
+        active_v_disp.val = 0;
+        active_v_disp.f.active_v_start=mode->upper_margin;
+        active_v_disp.f.active_v_end=mode->upper_margin + mode->yres;
+        writel(active_v_disp.val, remapped_regs + mmACTIVE_V_DISP);
+
+        graphic_h_disp.val = 0;
+        graphic_h_disp.f.graphic_h_start=mode->left_margin;
+        graphic_h_disp.f.graphic_h_end=mode->left_margin + mode->xres;
+        writel(graphic_h_disp.val, remapped_regs + mmGRAPHIC_H_DISP);
+
+        graphic_v_disp.val = 0;
+        graphic_v_disp.f.graphic_v_start=mode->upper_margin;
+        graphic_v_disp.f.graphic_v_end=mode->upper_margin + mode->yres;
+        writel(graphic_v_disp.val, remapped_regs + mmGRAPHIC_V_DISP);
+
+        crtc_total.val = 0;
+        crtc_total.f.crtc_h_total=mode->left_margin  + mode->xres + mode->right_margin;
+        crtc_total.f.crtc_v_total=mode->upper_margin + mode->yres + mode->lower_margin;
+        writel(crtc_total.val, remapped_regs + mmCRTC_TOTAL);
+
+        writel(mode->crtc_ss, remapped_regs + mmCRTC_SS);
+        writel(mode->crtc_ls, remapped_regs + mmCRTC_LS);
+        writel(mode->crtc_gs, remapped_regs + mmCRTC_GS);
+        writel(mode->crtc_vpos_gs, remapped_regs + mmCRTC_VPOS_GS);
+        writel(mode->crtc_rev, remapped_regs + mmCRTC_REV);
+        writel(mode->crtc_dclk, remapped_regs + mmCRTC_DCLK);
+        writel(mode->crtc_gclk, remapped_regs + mmCRTC_GCLK);
+        writel(mode->crtc_goe, remapped_regs + mmCRTC_GOE);
+        writel(mode->crtc_ps1_active, remapped_regs + mmCRTC_PS1_ACTIVE);
+
+        writel(regs->lcd_format, remapped_regs + mmLCD_FORMAT);
+        writel(regs->lcdd_cntl1, remapped_regs + mmLCDD_CNTL1);
+        writel(regs->lcdd_cntl2, remapped_regs + mmLCDD_CNTL2);
+        writel(regs->genlcd_cntl1, remapped_regs + mmGENLCD_CNTL1);
+        writel(regs->genlcd_cntl2, remapped_regs + mmGENLCD_CNTL2);
+        writel(regs->genlcd_cntl3, remapped_regs + mmGENLCD_CNTL3);
+
+        writel(0x00000000, remapped_regs + mmCRTC_FRAME);
+        writel(0x00000000, remapped_regs + mmCRTC_FRAME_VPOS);
+        writel(0x00000000, remapped_regs + mmCRTC_DEFAULT_COUNT);
+        writel(0x0000FF00, remapped_regs + mmLCD_BACKGROUND_COLOR);
 
         /* Hack for overlay in ext memory */
         temp32 = readl(remapped_regs + mmDISP_DEBUG2);
         temp32 |= 0xc0000000;
         writel(temp32, remapped_regs + mmDISP_DEBUG2);
-
-        /* Re-enable display updates */
-        disp_db_buf_wr_cntl.f.db_buf_cntl = 0x1e;
-        disp_db_buf_wr_cntl.f.update_db_buf = 1;
-        disp_db_buf_wr_cntl.f.en_db_buf = 1;
-        writel((u32) (disp_db_buf_wr_cntl.val), remapped_regs + mmDISP_DB_BUF_CNTL);
 }
 
 
-static void w100_set_vga_rotation_regs(u16 divider, unsigned long ctrl, unsigned long offset, unsigned long pitch)
+static void w100_setup_memory(struct w100fb_par *par)
 {
-        w100_pwr_state.pclk_cntl.f.pclk_src_sel = 0x1;
-        w100_pwr_state.pclk_cntl.f.pclk_post_div = divider;
-        writel((u32) (w100_pwr_state.pclk_cntl.val), remapped_regs + mmPCLK_CNTL);
+        union mc_ext_mem_location_u extmem_location;
+        union mc_fb_location_u intmem_location;
+        struct w100_mem_info *mem = par->mach->mem;
+        struct w100_bm_mem_info *bm_mem = par->mach->bm_mem;
 
-        writel(ctrl, remapped_regs + mmGRAPHIC_CTRL);
-        writel(offset, remapped_regs + mmGRAPHIC_OFFSET);
-        writel(pitch, remapped_regs + mmGRAPHIC_PITCH);
+        if (!par->extmem_active) {
+                w100_suspend(W100_SUSPEND_EXTMEM);
 
-        /* Re-enable display updates */
-        writel(0x0000007b, remapped_regs + mmDISP_DB_BUF_CNTL);
-}
+                /* Map Internal Memory at FB Base */
+                intmem_location.f.mc_fb_start = W100_FB_BASE >> 8;
+                intmem_location.f.mc_fb_top = (W100_FB_BASE+MEM_INT_SIZE) >> 8;
+                writel((u32) (intmem_location.val), remapped_regs + mmMC_FB_LOCATION);
 
+                /* Unmap External Memory - value is *probably* irrelevant but may have meaning
+                   to acceleration libraries */
+                extmem_location.f.mc_ext_mem_start = MEM_EXT_BASE_VALUE >> 8;
+                extmem_location.f.mc_ext_mem_top = (MEM_EXT_BASE_VALUE-1) >> 8;
+                writel((u32) (extmem_location.val), remapped_regs + mmMC_EXT_MEM_LOCATION);
+        } else {
+                /* Map Internal Memory to its default location */
+                intmem_location.f.mc_fb_start = MEM_INT_BASE_VALUE >> 8;
+                intmem_location.f.mc_fb_top = (MEM_INT_BASE_VALUE+MEM_INT_SIZE) >> 8;
+                writel((u32) (intmem_location.val), remapped_regs + mmMC_FB_LOCATION);
 
-static void w100_init_vga_rotation(u16 deg)
-{
-        switch(deg) {
-        case 0:
-                w100_set_vga_rotation_regs(0x02, 0x00DE1D66, 0x00800000, 0x000003c0);
-                break;
-        case 90:
-                w100_set_vga_rotation_regs(0x06, 0x00DE1D0e, 0x00895b00, 0x00000500);
-                break;
-        case 180:
-                w100_set_vga_rotation_regs(0x02, 0x00DE1D7e, 0x00895ffc, 0x000003c0);
-                break;
-        case 270:
-                w100_set_vga_rotation_regs(0x06, 0x00DE1D16, 0x008004fc, 0x00000500);
-                break;
-        default:
-                /* not-support */
-                break;
+                /* Map External Memory at FB Base */
+                extmem_location.f.mc_ext_mem_start = W100_FB_BASE >> 8;
+                extmem_location.f.mc_ext_mem_top = (W100_FB_BASE+par->mach->mem->size) >> 8;
+                writel((u32) (extmem_location.val), remapped_regs + mmMC_EXT_MEM_LOCATION);
+
+                writel(0x00007800, remapped_regs + mmMC_BIST_CTRL);
+                writel(mem->ext_cntl, remapped_regs + mmMEM_EXT_CNTL);
+                writel(0x00200021, remapped_regs + mmMEM_SDRAM_MODE_REG);
+                udelay(100);
+                writel(0x80200021, remapped_regs + mmMEM_SDRAM_MODE_REG);
+                udelay(100);
+                writel(mem->sdram_mode_reg, remapped_regs + mmMEM_SDRAM_MODE_REG);
+                udelay(100);
+                writel(mem->ext_timing_cntl, remapped_regs + mmMEM_EXT_TIMING_CNTL);
+                writel(mem->io_cntl, remapped_regs + mmMEM_IO_CNTL);
+                if (bm_mem) {
+                        writel(bm_mem->ext_mem_bw, remapped_regs + mmBM_EXT_MEM_BANDWIDTH);
+                        writel(bm_mem->offset, remapped_regs + mmBM_OFFSET);
+                        writel(bm_mem->ext_timing_ctl, remapped_regs + mmBM_MEM_EXT_TIMING_CNTL);
+                        writel(bm_mem->ext_cntl, remapped_regs + mmBM_MEM_EXT_CNTL);
+                        writel(bm_mem->mode_reg, remapped_regs + mmBM_MEM_MODE_REG);
+                        writel(bm_mem->io_cntl, remapped_regs + mmBM_MEM_IO_CNTL);
+                        writel(bm_mem->config, remapped_regs + mmBM_CONFIG);
+                }
         }
 }
 
-
-static void w100_set_qvga_rotation_regs(unsigned long ctrl, unsigned long offset, unsigned long pitch)
+static void w100_set_dispregs(struct w100fb_par *par)
 {
-        writel(ctrl, remapped_regs + mmGRAPHIC_CTRL);
-        writel(offset, remapped_regs + mmGRAPHIC_OFFSET);
-        writel(pitch, remapped_regs + mmGRAPHIC_PITCH);
+        unsigned long rot=0, divider, offset=0;
+        union graphic_ctrl_u graphic_ctrl;
+
+        /* See if the mode has been rotated */
+        if (par->xres == par->mode->xres) {
+                if (par->flip) {
+                        rot=3; /* 180 degree */
+                        offset=(par->xres * par->yres) - 1;
+                } /* else 0 degree */
+                divider = par->mode->pixclk_divider;
+        } else {
+                if (par->flip) {
+                        rot=2; /* 270 degree */
+                        offset=par->xres - 1;
+                } else {
+                        rot=1; /* 90 degree */
+                        offset=par->xres * (par->yres - 1);
+                }
+                divider = par->mode->pixclk_divider_rotated;
+        }
 
-        /* Re-enable display updates */
-        writel(0x0000007b, remapped_regs + mmDISP_DB_BUF_CNTL);
+        graphic_ctrl.val = 0; /* w32xx doesn't like undefined bits */
+        switch (par->chip_id) {
+                case CHIP_ID_W100:
+                        graphic_ctrl.f_w100.color_depth=6;
+                        graphic_ctrl.f_w100.en_crtc=1;
+                        graphic_ctrl.f_w100.en_graphic_req=1;
+                        graphic_ctrl.f_w100.en_graphic_crtc=1;
+                        graphic_ctrl.f_w100.lcd_pclk_on=1;
+                        graphic_ctrl.f_w100.lcd_sclk_on=1;
+                        graphic_ctrl.f_w100.low_power_on=0;
+                        graphic_ctrl.f_w100.req_freq=0;
+                        graphic_ctrl.f_w100.portrait_mode=rot;
+
+                        /* Zaurus needs this */
+                        switch(par->xres) {
+                                case 240:
+                                case 320:
+                                default:
+                                        graphic_ctrl.f_w100.total_req_graphic=0xa0;
+                                        break;
+                                case 480:
+                                case 640:
+                                        switch(rot) {
+                                                case 0:  /* 0 */
+                                                case 3:  /* 180 */
+                                                        graphic_ctrl.f_w100.low_power_on=1;
+                                                        graphic_ctrl.f_w100.req_freq=5;
+                                                break;
+                                                case 1:  /* 90 */
+                                                case 2:  /* 270 */
+                                                        graphic_ctrl.f_w100.req_freq=4;
+                                                        break;
+                                                default:
+                                                        break;
+                                        }
+                                        graphic_ctrl.f_w100.total_req_graphic=0xf0;
+                                        break;
+                        }
+                        break;
+                case CHIP_ID_W3200:
+                case CHIP_ID_W3220:
+                        graphic_ctrl.f_w32xx.color_depth=6;
+                        graphic_ctrl.f_w32xx.en_crtc=1;
+                        graphic_ctrl.f_w32xx.en_graphic_req=1;
+                        graphic_ctrl.f_w32xx.en_graphic_crtc=1;
+                        graphic_ctrl.f_w32xx.lcd_pclk_on=1;
+                        graphic_ctrl.f_w32xx.lcd_sclk_on=1;
+                        graphic_ctrl.f_w32xx.low_power_on=0;
+                        graphic_ctrl.f_w32xx.req_freq=0;
+                        graphic_ctrl.f_w32xx.total_req_graphic=par->mode->xres >> 1; /* panel xres, not mode */
+                        graphic_ctrl.f_w32xx.portrait_mode=rot;
+                        break;
+        }
+
+        /* Set the pixel clock source and divider */
+        w100_pwr_state.pclk_cntl.f.pclk_src_sel = par->mode->pixclk_src;
+        w100_pwr_state.pclk_cntl.f.pclk_post_div = divider;
+        writel((u32) (w100_pwr_state.pclk_cntl.val), remapped_regs + mmPCLK_CNTL);
+
+        writel(graphic_ctrl.val, remapped_regs + mmGRAPHIC_CTRL);
+        writel(W100_FB_BASE + ((offset * BITS_PER_PIXEL/8)&~0x03UL), remapped_regs + mmGRAPHIC_OFFSET);
+        writel((par->xres*BITS_PER_PIXEL/8), remapped_regs + mmGRAPHIC_PITCH);
 }
 
 
-static void w100_init_qvga_rotation(u16 deg)
+/*
+ * Work out how long the sync pulse lasts
+ * Value is 1/(time in seconds)
+ */
+static void calc_hsync(struct w100fb_par *par)
 {
-        switch(deg) {
-        case 0:
-                w100_set_qvga_rotation_regs(0x00d41c06, 0x00800000, 0x000001e0);
-                break;
-        case 90:
-                w100_set_qvga_rotation_regs(0x00d41c0E, 0x00825580, 0x00000280);
-                break;
-        case 180:
-                w100_set_qvga_rotation_regs(0x00d41c1e, 0x008257fc, 0x000001e0);
-                break;
-        case 270:
-                w100_set_qvga_rotation_regs(0x00d41c16, 0x0080027c, 0x00000280);
-                break;
-        default:
-                /* not-support */
-                break;
-        }
-}
+        unsigned long hsync;
+        struct w100_mode *mode = par->mode;
+        union crtc_ss_u crtc_ss;
+
+        if (mode->pixclk_src == CLK_SRC_XTAL)
+                hsync=par->mach->xtal_freq;
+        else
+                hsync=((par->fastpll_mode && mode->fast_pll_freq) ? mode->fast_pll_freq : mode->pll_freq)*100000;
 
+        hsync /= (w100_pwr_state.pclk_cntl.f.pclk_post_div + 1);
+
+        crtc_ss.val = readl(remapped_regs + mmCRTC_SS);
+        if (crtc_ss.val)
+                par->hsync_len = hsync / (crtc_ss.f.ss_end-crtc_ss.f.ss_start);
+        else
+                par->hsync_len = 0;
+}
 
 static void w100_suspend(u32 mode)
 {
@@ -1387,30 +1377,28 @@ static void w100_suspend(u32 mode)
         writel(0x00FF0000, remapped_regs + mmMC_PERF_MON_CNTL);
 
         val = readl(remapped_regs + mmMEM_EXT_TIMING_CNTL);
-        val &= ~(0x00100000);   /* bit20=0 */
-        val |= 0xFF000000;      /* bit31:24=0xff */
+        val &= ~(0x00100000);  /* bit20=0 */
+        val |= 0xFF000000;     /* bit31:24=0xff */
         writel(val, remapped_regs + mmMEM_EXT_TIMING_CNTL);
 
         val = readl(remapped_regs + mmMEM_EXT_CNTL);
-        val &= ~(0x00040000);   /* bit18=0 */
-        val |= 0x00080000;      /* bit19=1 */
+        val &= ~(0x00040000);  /* bit18=0 */
+        val |= 0x00080000;     /* bit19=1 */
         writel(val, remapped_regs + mmMEM_EXT_CNTL);
 
-        udelay(1);              /* wait 1us */
+        udelay(1);  /* wait 1us */
 
         if (mode == W100_SUSPEND_EXTMEM) {
-
                 /* CKE: Tri-State */
                 val = readl(remapped_regs + mmMEM_EXT_CNTL);
-                val |= 0x40000000;      /* bit30=1 */
+                val |= 0x40000000;  /* bit30=1 */
                 writel(val, remapped_regs + mmMEM_EXT_CNTL);
 
                 /* CLK: Stop */
                 val = readl(remapped_regs + mmMEM_EXT_CNTL);
-                val &= ~(0x00000001);   /* bit0=0 */
+                val &= ~(0x00000001);  /* bit0=0 */
                 writel(val, remapped_regs + mmMEM_EXT_CNTL);
         } else {
-
                 writel(0x00000000, remapped_regs + mmSCLK_CNTL);
                 writel(0x000000BF, remapped_regs + mmCLK_PIN_CNTL);
                 writel(0x00000015, remapped_regs + mmPWRMGT_CNTL);
@@ -1418,43 +1406,16 @@ static void w100_suspend(u32 mode)
                 udelay(5);
 
                 val = readl(remapped_regs + mmPLL_CNTL);
-                val |= 0x00000004;      /* bit2=1 */
+                val |= 0x00000004;  /* bit2=1 */
                 writel(val, remapped_regs + mmPLL_CNTL);
                 writel(0x0000001d, remapped_regs + mmPWRMGT_CNTL);
         }
 }
 
-
-static void w100_resume(void)
-{
-        u32 temp32;
-
-        w100_hw_init();
-        w100_pwm_setup();
-
-        temp32 = readl(remapped_regs + mmDISP_DEBUG2);
-        temp32 &= 0xff7fffff;
-        temp32 |= 0x00800000;
-        writel(temp32, remapped_regs + mmDISP_DEBUG2);
-
-        if (current_par->lcdMode == LCD_MODE_480 || current_par->lcdMode == LCD_MODE_640) {
-                w100_init_sharp_lcd(LCD_SHARP_VGA);
-                if (current_par->lcdMode == LCD_MODE_640) {
-                        w100_init_vga_rotation(current_par->rotation_flag ? 270 : 90);
-                }
-        } else {
-                w100_init_sharp_lcd(LCD_SHARP_QVGA);
-                if (current_par->lcdMode == LCD_MODE_320) {
-                        w100_init_qvga_rotation(current_par->rotation_flag ? 270 : 90);
-                }
-        }
-}
-
-
 static void w100_vsync(void)
 {
         u32 tmp;
-        int timeout = 30000; /* VSync timeout = 30[ms] > 16.8[ms] */
+        int timeout = 30000;  /* VSync timeout = 30[ms] > 16.8[ms] */
 
         tmp = readl(remapped_regs + mmACTIVE_V_DISP);
 
@@ -1490,363 +1451,6 @@ static void w100_vsync(void)
         writel(0x00000002, remapped_regs + mmGEN_INT_STATUS);
 }
 
-
-static void w100_InitExtMem(u32 mode)
-{
-        switch(mode) {
-        case LCD_SHARP_QVGA:
-                /* QVGA doesn't use external memory
-                   nothing to do, really. */
-                break;
-        case LCD_SHARP_VGA:
-                writel(0x00007800, remapped_regs + mmMC_BIST_CTRL);
-                writel(0x00040003, remapped_regs + mmMEM_EXT_CNTL);
-                writel(0x00200021, remapped_regs + mmMEM_SDRAM_MODE_REG);
-                udelay(100);
-                writel(0x80200021, remapped_regs + mmMEM_SDRAM_MODE_REG);
-                udelay(100);
-                writel(0x00650021, remapped_regs + mmMEM_SDRAM_MODE_REG);
-                udelay(100);
-                writel(0x10002a4a, remapped_regs + mmMEM_EXT_TIMING_CNTL);
-                writel(0x7ff87012, remapped_regs + mmMEM_IO_CNTL);
-                break;
-        default:
-                break;
-        }
-}
-
-
-#define RESCTL_ADRS     0x00
-#define PHACTRL_ADRS    0x01
-#define DUTYCTRL_ADRS   0x02
-#define POWERREG0_ADRS  0x03
-#define POWERREG1_ADRS  0x04
-#define GPOR3_ADRS              0x05
-#define PICTRL_ADRS     0x06
-#define POLCTRL_ADRS    0x07
-
-#define RESCTL_QVGA     0x01
-#define RESCTL_VGA      0x00
-
-#define POWER1_VW_ON    0x01    /* VW Supply FET ON */
-#define POWER1_GVSS_ON  0x02    /* GVSS(-8V) Power Supply ON */
-#define POWER1_VDD_ON   0x04    /* VDD(8V),SVSS(-4V) Power Supply ON */
-
-#define POWER1_VW_OFF   0x00    /* VW Supply FET OFF */
-#define POWER1_GVSS_OFF 0x00    /* GVSS(-8V) Power Supply OFF */
-#define POWER1_VDD_OFF  0x00    /* VDD(8V),SVSS(-4V) Power Supply OFF */
-
-#define POWER0_COM_DCLK 0x01    /* COM Voltage DC Bias DAC Serial Data Clock */
-#define POWER0_COM_DOUT 0x02    /* COM Voltage DC Bias DAC Serial Data Out */
-#define POWER0_DAC_ON   0x04    /* DAC Power Supply ON */
-#define POWER0_COM_ON   0x08    /* COM Powewr Supply ON */
-#define POWER0_VCC5_ON  0x10    /* VCC5 Power Supply ON */
-
-#define POWER0_DAC_OFF  0x00    /* DAC Power Supply OFF */
-#define POWER0_COM_OFF  0x00    /* COM Powewr Supply OFF */
-#define POWER0_VCC5_OFF 0x00    /* VCC5 Power Supply OFF */
-
-#define PICTRL_INIT_STATE       0x01
-#define PICTRL_INIOFF           0x02
-#define PICTRL_POWER_DOWN       0x04
-#define PICTRL_COM_SIGNAL_OFF   0x08
-#define PICTRL_DAC_SIGNAL_OFF   0x10
-
-#define PICTRL_POWER_ACTIVE     (0)
-
-#define POLCTRL_SYNC_POL_FALL   0x01
-#define POLCTRL_EN_POL_FALL     0x02
-#define POLCTRL_DATA_POL_FALL   0x04
-#define POLCTRL_SYNC_ACT_H      0x08
-#define POLCTRL_EN_ACT_L        0x10
-
-#define POLCTRL_SYNC_POL_RISE   0x00
-#define POLCTRL_EN_POL_RISE     0x00
-#define POLCTRL_DATA_POL_RISE   0x00
-#define POLCTRL_SYNC_ACT_L      0x00
-#define POLCTRL_EN_ACT_H        0x00
-
-#define PHACTRL_PHASE_MANUAL    0x01
-
-#define PHAD_QVGA_DEFAULT_VAL (9)
-#define COMADJ_DEFAULT        (125)
-
-static void lcdtg_ssp_send(u8 adrs, u8 data)
-{
-        w100fb_ssp_send(adrs,data);
-}
-
-/*
- * This is only a psuedo I2C interface. We can't use the standard kernel
- * routines as the interface is write only. We just assume the data is acked...
- */
-static void lcdtg_ssp_i2c_send(u8 data)
-{
-        lcdtg_ssp_send(POWERREG0_ADRS, data);
-        udelay(10);
-}
-
-static void lcdtg_i2c_send_bit(u8 data)
-{
-        lcdtg_ssp_i2c_send(data);
-        lcdtg_ssp_i2c_send(data | POWER0_COM_DCLK);
-        lcdtg_ssp_i2c_send(data);
-}
-
-static void lcdtg_i2c_send_start(u8 base)
-{
-        lcdtg_ssp_i2c_send(base | POWER0_COM_DCLK | POWER0_COM_DOUT);
-        lcdtg_ssp_i2c_send(base | POWER0_COM_DCLK);
-        lcdtg_ssp_i2c_send(base);
-}
-
-static void lcdtg_i2c_send_stop(u8 base)
-{
-        lcdtg_ssp_i2c_send(base);
-        lcdtg_ssp_i2c_send(base | POWER0_COM_DCLK);
-        lcdtg_ssp_i2c_send(base | POWER0_COM_DCLK | POWER0_COM_DOUT);
-}
-
-static void lcdtg_i2c_send_byte(u8 base, u8 data)
-{
-        int i;
-        for (i = 0; i < 8; i++) {
-                if (data & 0x80)
-                        lcdtg_i2c_send_bit(base | POWER0_COM_DOUT);
-                else
-                        lcdtg_i2c_send_bit(base);
-                data <<= 1;
-        }
-}
-
-static void lcdtg_i2c_wait_ack(u8 base)
-{
-        lcdtg_i2c_send_bit(base);
-}
-
-static void lcdtg_set_common_voltage(u8 base_data, u8 data)
-{
-        /* Set Common Voltage to M62332FP via I2C */
-        lcdtg_i2c_send_start(base_data);
-        lcdtg_i2c_send_byte(base_data, 0x9c);
-        lcdtg_i2c_wait_ack(base_data);
-        lcdtg_i2c_send_byte(base_data, 0x00);
-        lcdtg_i2c_wait_ack(base_data);
-        lcdtg_i2c_send_byte(base_data, data);
-        lcdtg_i2c_wait_ack(base_data);
-        lcdtg_i2c_send_stop(base_data);
-}
-
-static struct lcdtg_register_setting {
-        u8 adrs;
-        u8 data;
-        u32 wait;
-} lcdtg_power_on_table[] = {
-
-    /* Initialize Internal Logic & Port */
-    { PICTRL_ADRS,
-      PICTRL_POWER_DOWN | PICTRL_INIOFF | PICTRL_INIT_STATE |
-      PICTRL_COM_SIGNAL_OFF | PICTRL_DAC_SIGNAL_OFF,
-      0 },
-
-    { POWERREG0_ADRS,
-      POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_OFF | POWER0_COM_OFF |
-      POWER0_VCC5_OFF,
-      0 },
-
-    { POWERREG1_ADRS,
-      POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_OFF,
-      0 },
-
-    /* VDD(+8V),SVSS(-4V) ON */
-    { POWERREG1_ADRS,
-      POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_ON /* VDD ON */,
-      3000 },
-
-    /* DAC ON */
-    { POWERREG0_ADRS,
-      POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON /* DAC ON */ |
-      POWER0_COM_OFF | POWER0_VCC5_OFF,
-      0 },
-
-    /* INIB = H, INI = L  */
-    { PICTRL_ADRS,
-      /* PICTL[0] = H , PICTL[1] = PICTL[2] = PICTL[4] = L */
-      PICTRL_INIT_STATE | PICTRL_COM_SIGNAL_OFF,
-      0 },
-
-    /* Set Common Voltage */
-    { 0xfe, 0, 0 },
-
-    /* VCC5 ON */
-    { POWERREG0_ADRS,
-      POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON /* DAC ON */ |
-      POWER0_COM_OFF | POWER0_VCC5_ON /* VCC5 ON */,
-      0 },
-
-    /* GVSS(-8V) ON */
-    { POWERREG1_ADRS,
-      POWER1_VW_OFF | POWER1_GVSS_ON /* GVSS ON */ |
-      POWER1_VDD_ON /* VDD ON */,
-      2000 },
-
-    /* COM SIGNAL ON (PICTL[3] = L) */
-    { PICTRL_ADRS,
-      PICTRL_INIT_STATE,
-      0 },
-
-    /* COM ON */
-    { POWERREG0_ADRS,
-      POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON /* DAC ON */ |
-      POWER0_COM_ON /* COM ON */ | POWER0_VCC5_ON /* VCC5_ON */,
-      0 },
-
-    /* VW ON */
-    { POWERREG1_ADRS,
-      POWER1_VW_ON /* VW ON */ | POWER1_GVSS_ON /* GVSS ON */ |
-      POWER1_VDD_ON /* VDD ON */,
-      0 /* Wait 100ms */ },
-
-    /* Signals output enable */
-    { PICTRL_ADRS,
-      0 /* Signals output enable */,
-      0 },
-
-    { PHACTRL_ADRS,
-      PHACTRL_PHASE_MANUAL,
-      0 },
-
-    /* Initialize for Input Signals from ATI */
-    { POLCTRL_ADRS,
-      POLCTRL_SYNC_POL_RISE | POLCTRL_EN_POL_RISE | POLCTRL_DATA_POL_RISE |
-      POLCTRL_SYNC_ACT_L | POLCTRL_EN_ACT_H,
-      1000 /*100000*/ /* Wait 100ms */ },
-
-    /* end mark */
-    { 0xff, 0, 0 }
-};
-
-static void lcdtg_resume(void)
-{
-        if (current_par->lcdMode == LCD_MODE_480 || current_par->lcdMode == LCD_MODE_640) {
-                lcdtg_hw_init(LCD_SHARP_VGA);
-        } else {
-                lcdtg_hw_init(LCD_SHARP_QVGA);
-        }
-}
-
-static void lcdtg_suspend(void)
-{
-        int i;
-
-        for (i = 0; i < (current_par->xres * current_par->yres); i++) {
-                writew(0xffff, remapped_fbuf + (2*i));
-        }
-
-        /* 60Hz x 2 frame = 16.7msec x 2 = 33.4 msec */
-        mdelay(34);
-
-        /* (1)VW OFF */
-        lcdtg_ssp_send(POWERREG1_ADRS, POWER1_VW_OFF | POWER1_GVSS_ON | POWER1_VDD_ON);
-
-        /* (2)COM OFF */
-        lcdtg_ssp_send(PICTRL_ADRS, PICTRL_COM_SIGNAL_OFF);
-        lcdtg_ssp_send(POWERREG0_ADRS, POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_ON);
-
-        /* (3)Set Common Voltage Bias 0V */
-        lcdtg_set_common_voltage(POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_ON, 0);
-
-        /* (4)GVSS OFF */
-        lcdtg_ssp_send(POWERREG1_ADRS, POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_ON);
-
-        /* (5)VCC5 OFF */
-        lcdtg_ssp_send(POWERREG0_ADRS, POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_OFF);
-
-        /* (6)Set PDWN, INIOFF, DACOFF */
-        lcdtg_ssp_send(PICTRL_ADRS, PICTRL_INIOFF | PICTRL_DAC_SIGNAL_OFF |
-                        PICTRL_POWER_DOWN | PICTRL_COM_SIGNAL_OFF);
-
-        /* (7)DAC OFF */
-        lcdtg_ssp_send(POWERREG0_ADRS, POWER0_DAC_OFF | POWER0_COM_OFF | POWER0_VCC5_OFF);
-
-        /* (8)VDD OFF */
-        lcdtg_ssp_send(POWERREG1_ADRS, POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_OFF);
-
-}
-
-static void lcdtg_set_phadadj(u32 mode)
-{
-        int adj;
-
-        if (mode == LCD_SHARP_VGA) {
-                /* Setting for VGA */
-                adj = current_par->phadadj;
-                if (adj < 0) {
-                        adj = PHACTRL_PHASE_MANUAL;
-                } else {
-                        adj = ((adj & 0x0f) << 1) | PHACTRL_PHASE_MANUAL;
-                }
-        } else {
-                /* Setting for QVGA */
-                adj = (PHAD_QVGA_DEFAULT_VAL << 1) | PHACTRL_PHASE_MANUAL;
-        }
-        lcdtg_ssp_send(PHACTRL_ADRS, adj);
-}
-
-static void lcdtg_hw_init(u32 mode)
-{
-        int i;
-        int comadj;
-
-        i = 0;
-        while(lcdtg_power_on_table[i].adrs != 0xff) {
-                if (lcdtg_power_on_table[i].adrs == 0xfe) {
-                        /* Set Common Voltage */
-                        comadj = current_par->comadj;
-                        if (comadj < 0) {
-                                comadj = COMADJ_DEFAULT;
-                        }
-                        lcdtg_set_common_voltage((POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_OFF), comadj);
-                } else if (lcdtg_power_on_table[i].adrs == PHACTRL_ADRS) {
-                        /* Set Phase Adjuct */
-                        lcdtg_set_phadadj(mode);
-                } else {
-                        /* Other */
-                        lcdtg_ssp_send(lcdtg_power_on_table[i].adrs, lcdtg_power_on_table[i].data);
-                }
-                if (lcdtg_power_on_table[i].wait != 0)
-                        udelay(lcdtg_power_on_table[i].wait);
-                i++;
-        }
-
-        switch(mode) {
-        case LCD_SHARP_QVGA:
-                /* Set Lcd Resolution (QVGA) */
-                lcdtg_ssp_send(RESCTL_ADRS, RESCTL_QVGA);
-                break;
-        case LCD_SHARP_VGA:
-                /* Set Lcd Resolution (VGA) */
-                lcdtg_ssp_send(RESCTL_ADRS, RESCTL_VGA);
-                break;
-        default:
-                break;
-        }
-}
-
-static void lcdtg_lcd_change(u32 mode)
-{
-        /* Set Phase Adjuct */
-        lcdtg_set_phadadj(mode);
-
-        if (mode == LCD_SHARP_VGA)
-                /* Set Lcd Resolution (VGA) */
-                lcdtg_ssp_send(RESCTL_ADRS, RESCTL_VGA);
-        else if (mode == LCD_SHARP_QVGA)
-                /* Set Lcd Resolution (QVGA) */
-                lcdtg_ssp_send(RESCTL_ADRS, RESCTL_QVGA);
-}
-
-
 static struct device_driver w100fb_driver = {
         .name           = "w100fb",
         .bus            = &platform_bus_type,
@@ -1870,4 +1474,4 @@ module_init(w100fb_init);
 module_exit(w100fb_cleanup);
 
 MODULE_DESCRIPTION("ATI Imageon w100 framebuffer driver");
-MODULE_LICENSE("GPLv2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/w100fb.h b/drivers/video/w100fb.h
index 41624f961237..7a58a1e3e427 100644
--- a/drivers/video/w100fb.h
+++ b/drivers/video/w100fb.h
@@ -5,9 +5,12 @@
  *
  * Copyright (C) 2002, ATI Corp.
  * Copyright (C) 2004-2005 Richard Purdie
+ * Copyright (c) 2005 Ian Molton <spyro@f2s.com>
  *
  * Modified to work with 2.6 by Richard Purdie <rpurdie@rpsys.net>
  *
+ * w32xx support by Ian Molton
+ *
  * 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.
@@ -19,7 +22,7 @@
 
 /* Block CIF Start: */
 #define mmCHIP_ID           0x0000
-#define mmREVISION_ID           0x0004
+#define mmREVISION_ID       0x0004
 #define mmWRAP_BUF_A        0x0008
 #define mmWRAP_BUF_B        0x000C
 #define mmWRAP_TOP_DIR      0x0010
@@ -88,7 +91,7 @@
 #define mmDISP_DEBUG        0x04D4
 #define mmDISP_DB_BUF_CNTL  0x04D8
 #define mmDISP_CRC_SIG      0x04DC
-#define mmCRTC_DEFAULT_COUNT    0x04E0
+#define mmCRTC_DEFAULT_COUNT    0x04E0
 #define mmLCD_BACKGROUND_COLOR  0x04E4
 #define mmCRTC_PS2          0x04E8
 #define mmCRTC_PS2_VPOS     0x04EC
@@ -119,17 +122,17 @@
 /* Block DISPLAY End: */
 
 /* Block GFX Start: */
-#define mmBRUSH_OFFSET      0x108C
-#define mmBRUSH_Y_X         0x1074
-#define mmDEFAULT_PITCH_OFFSET          0x10A0
-#define mmDEFAULT_SC_BOTTOM_RIGHT       0x10A8
-#define mmDEFAULT2_SC_BOTTOM_RIGHT      0x10AC
-#define mmGLOBAL_ALPHA      0x1210
-#define mmFILTER_COEF       0x1214
-#define mmMVC_CNTL_START    0x11E0
-#define mmE2_ARITHMETIC_CNTL    0x1220
-#define mmENG_CNTL          0x13E8
-#define mmENG_PERF_CNT      0x13F0
+#define mmBRUSH_OFFSET        0x108C
+#define mmBRUSH_Y_X           0x1074
+#define mmDEFAULT_PITCH_OFFSET      0x10A0
+#define mmDEFAULT_SC_BOTTOM_RIGHT   0x10A8
+#define mmDEFAULT2_SC_BOTTOM_RIGHT  0x10AC
+#define mmGLOBAL_ALPHA        0x1210
+#define mmFILTER_COEF         0x1214
+#define mmMVC_CNTL_START      0x11E0
+#define mmE2_ARITHMETIC_CNTL  0x1220
+#define mmENG_CNTL            0x13E8
+#define mmENG_PERF_CNT        0x13F0
 /* Block GFX End: */
 
 /* Block IDCT Start: */
@@ -141,22 +144,38 @@
 /* Block IDCT End: */
 
 /* Block MC Start: */
-#define mmMEM_CNTL          0x0180
-#define mmMEM_ARB           0x0184
-#define mmMC_FB_LOCATION    0x0188
-#define mmMEM_EXT_CNTL      0x018C
-#define mmMC_EXT_MEM_LOCATION   0x0190
-#define mmMEM_EXT_TIMING_CNTL   0x0194
-#define mmMEM_SDRAM_MODE_REG    0x0198
-#define mmMEM_IO_CNTL       0x019C
-#define mmMC_DEBUG          0x01A0
-#define mmMC_BIST_CTRL      0x01A4
-#define mmMC_BIST_COLLAR_READ   0x01A8
-#define mmTC_MISMATCH       0x01AC
-#define mmMC_PERF_MON_CNTL  0x01B0
-#define mmMC_PERF_COUNTERS  0x01B4
+#define mmMEM_CNTL             0x0180
+#define mmMEM_ARB              0x0184
+#define mmMC_FB_LOCATION       0x0188
+#define mmMEM_EXT_CNTL         0x018C
+#define mmMC_EXT_MEM_LOCATION  0x0190
+#define mmMEM_EXT_TIMING_CNTL  0x0194
+#define mmMEM_SDRAM_MODE_REG   0x0198
+#define mmMEM_IO_CNTL          0x019C
+#define mmMC_DEBUG             0x01A0
+#define mmMC_BIST_CTRL         0x01A4
+#define mmMC_BIST_COLLAR_READ  0x01A8
+#define mmTC_MISMATCH          0x01AC
+#define mmMC_PERF_MON_CNTL     0x01B0
+#define mmMC_PERF_COUNTERS     0x01B4
 /* Block MC End: */
 
+/* Block BM Start: */
+#define mmBM_EXT_MEM_BANDWIDTH    0x0A00
+#define mmBM_OFFSET               0x0A04
+#define mmBM_MEM_EXT_TIMING_CNTL  0x0A08
+#define mmBM_MEM_EXT_CNTL         0x0A0C
+#define mmBM_MEM_MODE_REG         0x0A10
+#define mmBM_MEM_IO_CNTL          0x0A18
+#define mmBM_CONFIG               0x0A1C
+#define mmBM_STATUS               0x0A20
+#define mmBM_DEBUG                0x0A24
+#define mmBM_PERF_MON_CNTL        0x0A28
+#define mmBM_PERF_COUNTERS        0x0A2C
+#define mmBM_PERF2_MON_CNTL       0x0A30
+#define mmBM_PERF2_COUNTERS       0x0A34
+/* Block BM End: */
+
 /* Block RBBM Start: */
 #define mmWAIT_UNTIL        0x1400
 #define mmISYNC_CNTL        0x1404
@@ -176,439 +195,575 @@
 /* Block CG End: */
 
 /* default value definitions */
-#define defWRAP_TOP_DIR     0x00000000
-#define defWRAP_START_DIR       0x00000000
-#define defCFGREG_BASE      0x00000000
-#define defCIF_IO           0x000C0902
-#define defINTF_CNTL        0x00000011
-#define defCPU_DEFAULTS     0x00000006
-#define defHW_INT           0x00000000
-#define defMC_EXT_MEM_LOCATION            0x07ff0000
-#define defTC_MISMATCH      0x00000000
+#define defWRAP_TOP_DIR        0x00000000
+#define defWRAP_START_DIR      0x00000000
+#define defCFGREG_BASE         0x00000000
+#define defCIF_IO              0x000C0902
+#define defINTF_CNTL           0x00000011
+#define defCPU_DEFAULTS        0x00000006
+#define defHW_INT              0x00000000
+#define defMC_EXT_MEM_LOCATION 0x07ff0000
+#define defTC_MISMATCH         0x00000000
 
 #define W100_CFG_BASE          0x0
 #define W100_CFG_LEN           0x10
 #define W100_REG_BASE          0x10000
 #define W100_REG_LEN           0x2000
 #define MEM_INT_BASE_VALUE     0x100000
-#define MEM_INT_TOP_VALUE_W100 0x15ffff
 #define MEM_EXT_BASE_VALUE     0x800000
-#define MEM_EXT_TOP_VALUE      0x9fffff
+#define MEM_INT_SIZE           0x05ffff
+#define MEM_WINDOW_BASE        0x100000
+#define MEM_WINDOW_SIZE        0xf00000
+
 #define WRAP_BUF_BASE_VALUE    0x80000
 #define WRAP_BUF_TOP_VALUE     0xbffff
 
+#define CHIP_ID_W100           0x57411002
+#define CHIP_ID_W3200          0x56441002
+#define CHIP_ID_W3220          0x57441002
 
-/* data structure definitions */
+/* Register structure definitions */
 
 struct wrap_top_dir_t {
-     unsigned long top_addr         : 23;
-     unsigned long                              : 9;
+        unsigned long top_addr  : 23;
+        unsigned long           : 9;
 } __attribute__((packed));
 
 union wrap_top_dir_u {
-     unsigned long val : 32;
-     struct wrap_top_dir_t f;
+        unsigned long val : 32;
+        struct wrap_top_dir_t f;
 } __attribute__((packed));
 
 struct wrap_start_dir_t {
-     unsigned long start_addr       : 23;
-     unsigned long                              : 9;
+        unsigned long start_addr : 23;
+        unsigned long            : 9;
 } __attribute__((packed));
 
 union wrap_start_dir_u {
-     unsigned long val : 32;
-     struct wrap_start_dir_t f;
+        unsigned long val : 32;
+        struct wrap_start_dir_t f;
 } __attribute__((packed));
 
 struct cif_cntl_t {
-     unsigned long swap_reg                     : 2;
-     unsigned long swap_fbuf_1                  : 2;
-     unsigned long swap_fbuf_2                  : 2;
-     unsigned long swap_fbuf_3                  : 2;
-     unsigned long pmi_int_disable              : 1;
-     unsigned long pmi_schmen_disable       : 1;
-     unsigned long intb_oe                      : 1;
-     unsigned long en_wait_to_compensate_dq_prop_dly : 1;
-     unsigned long compensate_wait_rd_size  : 2;
-     unsigned long wait_asserted_timeout_val      : 2;
-     unsigned long wait_masked_val              : 2;
-     unsigned long en_wait_timeout              : 1;
-     unsigned long en_one_clk_setup_before_wait   : 1;
-     unsigned long interrupt_active_high    : 1;
-     unsigned long en_overwrite_straps      : 1;
-     unsigned long strap_wait_active_hi     : 1;
-     unsigned long lat_busy_count               : 2;
-     unsigned long lat_rd_pm4_sclk_busy     : 1;
-     unsigned long dis_system_bits              : 1;
-     unsigned long dis_mr                       : 1;
-     unsigned long cif_spare_1                  : 4;
+        unsigned long swap_reg                 : 2;
+        unsigned long swap_fbuf_1              : 2;
+        unsigned long swap_fbuf_2              : 2;
+        unsigned long swap_fbuf_3              : 2;
+        unsigned long pmi_int_disable          : 1;
+        unsigned long pmi_schmen_disable       : 1;
+        unsigned long intb_oe                  : 1;
+        unsigned long en_wait_to_compensate_dq_prop_dly  : 1;
+        unsigned long compensate_wait_rd_size  : 2;
+        unsigned long wait_asserted_timeout_val  : 2;
+        unsigned long wait_masked_val          : 2;
+        unsigned long en_wait_timeout          : 1;
+        unsigned long en_one_clk_setup_before_wait  : 1;
+        unsigned long interrupt_active_high    : 1;
+        unsigned long en_overwrite_straps      : 1;
+        unsigned long strap_wait_active_hi     : 1;
+        unsigned long lat_busy_count           : 2;
+        unsigned long lat_rd_pm4_sclk_busy     : 1;
+        unsigned long dis_system_bits          : 1;
+        unsigned long dis_mr                   : 1;
+        unsigned long cif_spare_1              : 4;
 } __attribute__((packed));
 
 union cif_cntl_u {
-     unsigned long val : 32;
-     struct cif_cntl_t f;
+        unsigned long val : 32;
+        struct cif_cntl_t f;
 } __attribute__((packed));
 
 struct cfgreg_base_t {
-     unsigned long cfgreg_base      : 24;
-     unsigned long                              : 8;
+        unsigned long cfgreg_base  : 24;
+        unsigned long              : 8;
 } __attribute__((packed));
 
 union cfgreg_base_u {
-     unsigned long val : 32;
-     struct cfgreg_base_t f;
+        unsigned long val : 32;
+        struct cfgreg_base_t f;
 } __attribute__((packed));
 
 struct cif_io_t {
-     unsigned long dq_srp           : 1;
-     unsigned long dq_srn           : 1;
-     unsigned long dq_sp            : 4;
-     unsigned long dq_sn            : 4;
-     unsigned long waitb_srp        : 1;
-     unsigned long waitb_srn        : 1;
-     unsigned long waitb_sp         : 4;
-     unsigned long waitb_sn         : 4;
-     unsigned long intb_srp         : 1;
-     unsigned long intb_srn         : 1;
-     unsigned long intb_sp          : 4;
-     unsigned long intb_sn          : 4;
-     unsigned long                              : 2;
+        unsigned long dq_srp     : 1;
+        unsigned long dq_srn     : 1;
+        unsigned long dq_sp      : 4;
+        unsigned long dq_sn      : 4;
+        unsigned long waitb_srp  : 1;
+        unsigned long waitb_srn  : 1;
+        unsigned long waitb_sp   : 4;
+        unsigned long waitb_sn   : 4;
+        unsigned long intb_srp   : 1;
+        unsigned long intb_srn   : 1;
+        unsigned long intb_sp    : 4;
+        unsigned long intb_sn    : 4;
+        unsigned long            : 2;
 } __attribute__((packed));
 
 union cif_io_u {
-     unsigned long val : 32;
-     struct cif_io_t f;
+        unsigned long val : 32;
+        struct cif_io_t f;
 } __attribute__((packed));
 
 struct cif_read_dbg_t {
-     unsigned long unpacker_pre_fetch_trig_gen  : 2;
-     unsigned long dly_second_rd_fetch_trig     : 1;
-     unsigned long rst_rd_burst_id                      : 1;
-     unsigned long dis_rd_burst_id                      : 1;
-     unsigned long en_block_rd_when_packer_is_not_emp : 1;
-     unsigned long dis_pre_fetch_cntl_sm        : 1;
-     unsigned long rbbm_chrncy_dis                      : 1;
-     unsigned long rbbm_rd_after_wr_lat         : 2;
-     unsigned long dis_be_during_rd                     : 1;
-     unsigned long one_clk_invalidate_pulse     : 1;
-     unsigned long dis_chnl_priority                    : 1;
-     unsigned long rst_read_path_a_pls          : 1;
-     unsigned long rst_read_path_b_pls          : 1;
-     unsigned long dis_reg_rd_fetch_trig        : 1;
-     unsigned long dis_rd_fetch_trig_from_ind_addr : 1;
-     unsigned long dis_rd_same_byte_to_trig_fetch : 1;
-     unsigned long dis_dir_wrap                         : 1;
-     unsigned long dis_ring_buf_to_force_dec    : 1;
-     unsigned long dis_addr_comp_in_16bit       : 1;
-     unsigned long clr_w                                : 1;
-     unsigned long err_rd_tag_is_3                      : 1;
-     unsigned long err_load_when_ful_a          : 1;
-     unsigned long err_load_when_ful_b          : 1;
-     unsigned long                                                      : 7;
+        unsigned long unpacker_pre_fetch_trig_gen  : 2;
+        unsigned long dly_second_rd_fetch_trig     : 1;
+        unsigned long rst_rd_burst_id              : 1;
+        unsigned long dis_rd_burst_id              : 1;
+        unsigned long en_block_rd_when_packer_is_not_emp : 1;
+        unsigned long dis_pre_fetch_cntl_sm        : 1;
+        unsigned long rbbm_chrncy_dis              : 1;
+        unsigned long rbbm_rd_after_wr_lat         : 2;
+        unsigned long dis_be_during_rd             : 1;
+        unsigned long one_clk_invalidate_pulse     : 1;
+        unsigned long dis_chnl_priority            : 1;
+        unsigned long rst_read_path_a_pls          : 1;
+        unsigned long rst_read_path_b_pls          : 1;
+        unsigned long dis_reg_rd_fetch_trig        : 1;
+        unsigned long dis_rd_fetch_trig_from_ind_addr : 1;
+        unsigned long dis_rd_same_byte_to_trig_fetch : 1;
+        unsigned long dis_dir_wrap                 : 1;
+        unsigned long dis_ring_buf_to_force_dec    : 1;
+        unsigned long dis_addr_comp_in_16bit       : 1;
+        unsigned long clr_w                        : 1;
+        unsigned long err_rd_tag_is_3              : 1;
+        unsigned long err_load_when_ful_a          : 1;
+        unsigned long err_load_when_ful_b          : 1;
+        unsigned long                              : 7;
 } __attribute__((packed));
 
 union cif_read_dbg_u {
-     unsigned long val : 32;
-     struct cif_read_dbg_t f;
+        unsigned long val : 32;
+        struct cif_read_dbg_t f;
 } __attribute__((packed));
 
 struct cif_write_dbg_t {
-     unsigned long packer_timeout_count           : 2;
-     unsigned long en_upper_load_cond             : 1;
-     unsigned long en_chnl_change_cond            : 1;
-     unsigned long dis_addr_comp_cond             : 1;
-     unsigned long dis_load_same_byte_addr_cond   : 1;
-     unsigned long dis_timeout_cond                       : 1;
-     unsigned long dis_timeout_during_rbbm        : 1;
-     unsigned long dis_packer_ful_during_rbbm_timeout : 1;
-     unsigned long en_dword_split_to_rbbm         : 1;
-     unsigned long en_dummy_val                           : 1;
-     unsigned long dummy_val_sel                          : 1;
-     unsigned long mask_pm4_wrptr_dec             : 1;
-     unsigned long dis_mc_clean_cond                      : 1;
-     unsigned long err_two_reqi_during_ful        : 1;
-     unsigned long err_reqi_during_idle_clk       : 1;
-     unsigned long err_global                             : 1;
-     unsigned long en_wr_buf_dbg_load             : 1;
-     unsigned long en_wr_buf_dbg_path             : 1;
-     unsigned long sel_wr_buf_byte                        : 3;
-     unsigned long dis_rd_flush_wr                        : 1;
-     unsigned long dis_packer_ful_cond            : 1;
-     unsigned long dis_invalidate_by_ops_chnl     : 1;
-     unsigned long en_halt_when_reqi_err          : 1;
-     unsigned long cif_spare_2                            : 5;
-     unsigned long                                                        : 1;
+        unsigned long packer_timeout_count          : 2;
+        unsigned long en_upper_load_cond            : 1;
+        unsigned long en_chnl_change_cond           : 1;
+        unsigned long dis_addr_comp_cond            : 1;
+        unsigned long dis_load_same_byte_addr_cond  : 1;
+        unsigned long dis_timeout_cond              : 1;
+        unsigned long dis_timeout_during_rbbm       : 1;
+        unsigned long dis_packer_ful_during_rbbm_timeout : 1;
+        unsigned long en_dword_split_to_rbbm        : 1;
+        unsigned long en_dummy_val                  : 1;
+        unsigned long dummy_val_sel                 : 1;
+        unsigned long mask_pm4_wrptr_dec            : 1;
+        unsigned long dis_mc_clean_cond             : 1;
+        unsigned long err_two_reqi_during_ful       : 1;
+        unsigned long err_reqi_during_idle_clk      : 1;
+        unsigned long err_global                    : 1;
+        unsigned long en_wr_buf_dbg_load            : 1;
+        unsigned long en_wr_buf_dbg_path            : 1;
+        unsigned long sel_wr_buf_byte               : 3;
+        unsigned long dis_rd_flush_wr               : 1;
+        unsigned long dis_packer_ful_cond           : 1;
+        unsigned long dis_invalidate_by_ops_chnl    : 1;
+        unsigned long en_halt_when_reqi_err         : 1;
+        unsigned long cif_spare_2                   : 5;
+        unsigned long                               : 1;
 } __attribute__((packed));
 
 union cif_write_dbg_u {
-     unsigned long val : 32;
-     struct cif_write_dbg_t f;
+        unsigned long val : 32;
+        struct cif_write_dbg_t f;
 } __attribute__((packed));
 
 
 struct intf_cntl_t {
-     unsigned char ad_inc_a            : 1;
-     unsigned char ring_buf_a          : 1;
-     unsigned char rd_fetch_trigger_a  : 1;
-     unsigned char rd_data_rdy_a       : 1;
-     unsigned char ad_inc_b            : 1;
-     unsigned char ring_buf_b          : 1;
-     unsigned char rd_fetch_trigger_b  : 1;
-     unsigned char rd_data_rdy_b       : 1;
+        unsigned char ad_inc_a            : 1;
+        unsigned char ring_buf_a          : 1;
+        unsigned char rd_fetch_trigger_a  : 1;
+        unsigned char rd_data_rdy_a       : 1;
+        unsigned char ad_inc_b            : 1;
+        unsigned char ring_buf_b          : 1;
+        unsigned char rd_fetch_trigger_b  : 1;
+        unsigned char rd_data_rdy_b       : 1;
 } __attribute__((packed));
 
 union intf_cntl_u {
-     unsigned char val : 8;
-     struct intf_cntl_t f;
+        unsigned char val : 8;
+        struct intf_cntl_t f;
 } __attribute__((packed));
 
 struct cpu_defaults_t {
-     unsigned char unpack_rd_data   : 1;
-     unsigned char access_ind_addr_a: 1;
-     unsigned char access_ind_addr_b: 1;
-     unsigned char access_scratch_reg             : 1;
-     unsigned char pack_wr_data     : 1;
-     unsigned char transition_size  : 1;
-     unsigned char en_read_buf_mode : 1;
-     unsigned char rd_fetch_scratch : 1;
+        unsigned char unpack_rd_data     : 1;
+        unsigned char access_ind_addr_a  : 1;
+        unsigned char access_ind_addr_b  : 1;
+        unsigned char access_scratch_reg : 1;
+        unsigned char pack_wr_data       : 1;
+        unsigned char transition_size    : 1;
+        unsigned char en_read_buf_mode   : 1;
+        unsigned char rd_fetch_scratch   : 1;
 } __attribute__((packed));
 
 union cpu_defaults_u {
-     unsigned char val : 8;
-     struct cpu_defaults_t f;
+        unsigned char val : 8;
+        struct cpu_defaults_t f;
+} __attribute__((packed));
+
+struct crtc_total_t {
+        unsigned long crtc_h_total : 10;
+        unsigned long              : 6;
+        unsigned long crtc_v_total : 10;
+        unsigned long              : 6;
+} __attribute__((packed));
+
+union crtc_total_u {
+        unsigned long val : 32;
+        struct crtc_total_t f;
+} __attribute__((packed));
+
+struct crtc_ss_t {
+        unsigned long ss_start    : 10;
+        unsigned long             : 6;
+        unsigned long ss_end      : 10;
+        unsigned long             : 2;
+        unsigned long ss_align    : 1;
+        unsigned long ss_pol      : 1;
+        unsigned long ss_run_mode : 1;
+        unsigned long ss_en       : 1;
+} __attribute__((packed));
+
+union crtc_ss_u {
+        unsigned long val : 32;
+        struct crtc_ss_t f;
+} __attribute__((packed));
+
+struct active_h_disp_t {
+        unsigned long active_h_start  : 10;
+        unsigned long                 : 6;
+        unsigned long active_h_end    : 10;
+        unsigned long                 : 6;
+} __attribute__((packed));
+
+union active_h_disp_u {
+        unsigned long val : 32;
+        struct active_h_disp_t f;
+} __attribute__((packed));
+
+struct active_v_disp_t {
+        unsigned long active_v_start  : 10;
+        unsigned long                 : 6;
+        unsigned long active_v_end    : 10;
+        unsigned long                 : 6;
+} __attribute__((packed));
+
+union active_v_disp_u {
+        unsigned long val : 32;
+        struct active_v_disp_t f;
+} __attribute__((packed));
+
+struct graphic_h_disp_t {
+        unsigned long graphic_h_start : 10;
+        unsigned long                 : 6;
+        unsigned long graphic_h_end   : 10;
+        unsigned long                 : 6;
+} __attribute__((packed));
+
+union graphic_h_disp_u {
+        unsigned long val : 32;
+        struct graphic_h_disp_t f;
+} __attribute__((packed));
+
+struct graphic_v_disp_t {
+        unsigned long graphic_v_start : 10;
+        unsigned long                 : 6;
+        unsigned long graphic_v_end   : 10;
+        unsigned long                 : 6;
+} __attribute__((packed));
+
+union graphic_v_disp_u{
+        unsigned long val : 32;
+        struct graphic_v_disp_t f;
+} __attribute__((packed));
+
+struct graphic_ctrl_t_w100 {
+        unsigned long color_depth       : 3;
+        unsigned long portrait_mode     : 2;
+        unsigned long low_power_on      : 1;
+        unsigned long req_freq          : 4;
+        unsigned long en_crtc           : 1;
+        unsigned long en_graphic_req    : 1;
+        unsigned long en_graphic_crtc   : 1;
+        unsigned long total_req_graphic : 9;
+        unsigned long lcd_pclk_on       : 1;
+        unsigned long lcd_sclk_on       : 1;
+        unsigned long pclk_running      : 1;
+        unsigned long sclk_running      : 1;
+        unsigned long                   : 6;
+} __attribute__((packed));
+
+struct graphic_ctrl_t_w32xx {
+        unsigned long color_depth       : 3;
+        unsigned long portrait_mode     : 2;
+        unsigned long low_power_on      : 1;
+        unsigned long req_freq          : 4;
+        unsigned long en_crtc           : 1;
+        unsigned long en_graphic_req    : 1;
+        unsigned long en_graphic_crtc   : 1;
+        unsigned long total_req_graphic : 10;
+        unsigned long lcd_pclk_on       : 1;
+        unsigned long lcd_sclk_on       : 1;
+        unsigned long pclk_running      : 1;
+        unsigned long sclk_running      : 1;
+        unsigned long                   : 5;
+} __attribute__((packed));
+
+union graphic_ctrl_u {
+        unsigned long val : 32;
+        struct graphic_ctrl_t_w100 f_w100;
+        struct graphic_ctrl_t_w32xx f_w32xx;
 } __attribute__((packed));
 
 struct video_ctrl_t {
-     unsigned long video_mode       : 1;
-     unsigned long keyer_en         : 1;
-     unsigned long en_video_req     : 1;
-     unsigned long en_graphic_req_video           : 1;
-     unsigned long en_video_crtc    : 1;
-     unsigned long video_hor_exp    : 2;
-     unsigned long video_ver_exp    : 2;
-     unsigned long uv_combine       : 1;
-     unsigned long total_req_video  : 9;
-     unsigned long video_ch_sel     : 1;
-     unsigned long video_portrait   : 2;
-     unsigned long yuv2rgb_en       : 1;
-     unsigned long yuv2rgb_option   : 1;
-     unsigned long video_inv_hor    : 1;
-     unsigned long video_inv_ver    : 1;
-     unsigned long gamma_sel        : 2;
-     unsigned long dis_limit        : 1;
-     unsigned long en_uv_hblend     : 1;
-     unsigned long rgb_gamma_sel    : 2;
+        unsigned long video_mode       : 1;
+        unsigned long keyer_en         : 1;
+        unsigned long en_video_req     : 1;
+        unsigned long en_graphic_req_video  : 1;
+        unsigned long en_video_crtc    : 1;
+        unsigned long video_hor_exp    : 2;
+        unsigned long video_ver_exp    : 2;
+        unsigned long uv_combine       : 1;
+        unsigned long total_req_video  : 9;
+        unsigned long video_ch_sel     : 1;
+        unsigned long video_portrait   : 2;
+        unsigned long yuv2rgb_en       : 1;
+        unsigned long yuv2rgb_option   : 1;
+        unsigned long video_inv_hor    : 1;
+        unsigned long video_inv_ver    : 1;
+        unsigned long gamma_sel        : 2;
+        unsigned long dis_limit        : 1;
+        unsigned long en_uv_hblend     : 1;
+        unsigned long rgb_gamma_sel    : 2;
 } __attribute__((packed));
 
 union video_ctrl_u {
-     unsigned long val : 32;
-     struct video_ctrl_t f;
+        unsigned long val : 32;
+        struct video_ctrl_t f;
 } __attribute__((packed));
 
 struct disp_db_buf_cntl_rd_t {
-     unsigned long en_db_buf            : 1;
-     unsigned long update_db_buf_done   : 1;
-     unsigned long db_buf_cntl          : 6;
-     unsigned long                                      : 24;
+        unsigned long en_db_buf           : 1;
+        unsigned long update_db_buf_done  : 1;
+        unsigned long db_buf_cntl         : 6;
+        unsigned long                     : 24;
 } __attribute__((packed));
 
 union disp_db_buf_cntl_rd_u {
-     unsigned long val : 32;
-     struct disp_db_buf_cntl_rd_t f;
+        unsigned long val : 32;
+        struct disp_db_buf_cntl_rd_t f;
 } __attribute__((packed));
 
 struct disp_db_buf_cntl_wr_t {
-     unsigned long en_db_buf        : 1;
-     unsigned long update_db_buf    : 1;
-     unsigned long db_buf_cntl      : 6;
-     unsigned long    : 24;
+        unsigned long en_db_buf      : 1;
+        unsigned long update_db_buf  : 1;
+        unsigned long db_buf_cntl    : 6;
+        unsigned long                : 24;
 } __attribute__((packed));
 
 union disp_db_buf_cntl_wr_u {
-     unsigned long val : 32;
-     struct disp_db_buf_cntl_wr_t f;
+        unsigned long val : 32;
+        struct disp_db_buf_cntl_wr_t f;
 } __attribute__((packed));
 
 struct gamma_value1_t {
-     unsigned long gamma1           : 8;
-     unsigned long gamma2           : 8;
-     unsigned long gamma3           : 8;
-     unsigned long gamma4           : 8;
+        unsigned long gamma1   : 8;
+        unsigned long gamma2   : 8;
+        unsigned long gamma3   : 8;
+        unsigned long gamma4   : 8;
 } __attribute__((packed));
 
 union gamma_value1_u {
-     unsigned long val : 32;
-     struct gamma_value1_t f;
+        unsigned long val : 32;
+        struct gamma_value1_t f;
 } __attribute__((packed));
 
 struct gamma_value2_t {
-     unsigned long gamma5           : 8;
-     unsigned long gamma6           : 8;
-     unsigned long gamma7           : 8;
-     unsigned long gamma8           : 8;
+        unsigned long gamma5   : 8;
+        unsigned long gamma6   : 8;
+        unsigned long gamma7   : 8;
+        unsigned long gamma8   : 8;
 } __attribute__((packed));
 
 union gamma_value2_u {
-     unsigned long val : 32;
-     struct gamma_value2_t f;
+        unsigned long val : 32;
+        struct gamma_value2_t f;
 } __attribute__((packed));
 
 struct gamma_slope_t {
-     unsigned long slope1           : 3;
-     unsigned long slope2           : 3;
-     unsigned long slope3           : 3;
-     unsigned long slope4           : 3;
-     unsigned long slope5           : 3;
-     unsigned long slope6           : 3;
-     unsigned long slope7           : 3;
-     unsigned long slope8           : 3;
-     unsigned long                              : 8;
+        unsigned long slope1   : 3;
+        unsigned long slope2   : 3;
+        unsigned long slope3   : 3;
+        unsigned long slope4   : 3;
+        unsigned long slope5   : 3;
+        unsigned long slope6   : 3;
+        unsigned long slope7   : 3;
+        unsigned long slope8   : 3;
+        unsigned long          : 8;
 } __attribute__((packed));
 
 union gamma_slope_u {
-     unsigned long val : 32;
-     struct gamma_slope_t f;
+        unsigned long val : 32;
+        struct gamma_slope_t f;
 } __attribute__((packed));
 
 struct mc_ext_mem_location_t {
-     unsigned long mc_ext_mem_start : 16;
-     unsigned long mc_ext_mem_top   : 16;
+        unsigned long mc_ext_mem_start : 16;
+        unsigned long mc_ext_mem_top   : 16;
 } __attribute__((packed));
 
 union mc_ext_mem_location_u {
-     unsigned long val : 32;
-     struct mc_ext_mem_location_t f;
+        unsigned long val : 32;
+        struct mc_ext_mem_location_t f;
+} __attribute__((packed));
+
+struct mc_fb_location_t {
+        unsigned long mc_fb_start      : 16;
+        unsigned long mc_fb_top        : 16;
+} __attribute__((packed));
+
+union mc_fb_location_u {
+        unsigned long val : 32;
+        struct mc_fb_location_t f;
 } __attribute__((packed));
 
 struct clk_pin_cntl_t {
-     unsigned long osc_en           : 1;
-     unsigned long osc_gain         : 5;
-     unsigned long dont_use_xtalin  : 1;
-     unsigned long xtalin_pm_en     : 1;
-     unsigned long xtalin_dbl_en    : 1;
-     unsigned long                              : 7;
-     unsigned long cg_debug         : 16;
+        unsigned long osc_en           : 1;
+        unsigned long osc_gain         : 5;
+        unsigned long dont_use_xtalin  : 1;
+        unsigned long xtalin_pm_en     : 1;
+        unsigned long xtalin_dbl_en    : 1;
+        unsigned long                  : 7;
+        unsigned long cg_debug         : 16;
 } __attribute__((packed));
 
 union clk_pin_cntl_u {
-     unsigned long val : 32;
-     struct clk_pin_cntl_t f;
+        unsigned long val : 32;
+        struct clk_pin_cntl_t f;
 } __attribute__((packed));
 
 struct pll_ref_fb_div_t {
-     unsigned long pll_ref_div      : 4;
-     unsigned long                              : 4;
-     unsigned long pll_fb_div_int   : 6;
-     unsigned long                              : 2;
-     unsigned long pll_fb_div_frac  : 3;
-     unsigned long                              : 1;
-     unsigned long pll_reset_time   : 4;
-     unsigned long pll_lock_time    : 8;
+        unsigned long pll_ref_div      : 4;
+        unsigned long                  : 4;
+        unsigned long pll_fb_div_int   : 6;
+        unsigned long                  : 2;
+        unsigned long pll_fb_div_frac  : 3;
+        unsigned long                  : 1;
+        unsigned long pll_reset_time   : 4;
+        unsigned long pll_lock_time    : 8;
 } __attribute__((packed));
 
 union pll_ref_fb_div_u {
-     unsigned long val : 32;
-     struct pll_ref_fb_div_t f;
+        unsigned long val : 32;
+        struct pll_ref_fb_div_t f;
 } __attribute__((packed));
 
 struct pll_cntl_t {
-     unsigned long pll_pwdn         : 1;
-     unsigned long pll_reset        : 1;
-     unsigned long pll_pm_en        : 1;
-     unsigned long pll_mode         : 1;
-     unsigned long pll_refclk_sel   : 1;
-     unsigned long pll_fbclk_sel    : 1;
-     unsigned long pll_tcpoff       : 1;
-     unsigned long pll_pcp          : 3;
-     unsigned long pll_pvg          : 3;
-     unsigned long pll_vcofr        : 1;
-     unsigned long pll_ioffset      : 2;
-     unsigned long pll_pecc_mode    : 2;
-     unsigned long pll_pecc_scon    : 2;
-     unsigned long pll_dactal       : 4;
-     unsigned long pll_cp_clip      : 2;
-     unsigned long pll_conf         : 3;
-     unsigned long pll_mbctrl       : 2;
-     unsigned long pll_ring_off     : 1;
+        unsigned long pll_pwdn        : 1;
+        unsigned long pll_reset       : 1;
+        unsigned long pll_pm_en       : 1;
+        unsigned long pll_mode        : 1;
+        unsigned long pll_refclk_sel  : 1;
+        unsigned long pll_fbclk_sel   : 1;
+        unsigned long pll_tcpoff      : 1;
+        unsigned long pll_pcp         : 3;
+        unsigned long pll_pvg         : 3;
+        unsigned long pll_vcofr       : 1;
+        unsigned long pll_ioffset     : 2;
+        unsigned long pll_pecc_mode   : 2;
+        unsigned long pll_pecc_scon   : 2;
+        unsigned long pll_dactal      : 4;
+        unsigned long pll_cp_clip     : 2;
+        unsigned long pll_conf        : 3;
+        unsigned long pll_mbctrl      : 2;
+        unsigned long pll_ring_off    : 1;
 } __attribute__((packed));
 
 union pll_cntl_u {
-     unsigned long val : 32;
-     struct pll_cntl_t f;
+        unsigned long val : 32;
+        struct pll_cntl_t f;
 } __attribute__((packed));
 
 struct sclk_cntl_t {
-     unsigned long sclk_src_sel         : 2;
-     unsigned long                                      : 2;
-     unsigned long sclk_post_div_fast   : 4;
-     unsigned long sclk_clkon_hys       : 3;
-     unsigned long sclk_post_div_slow   : 4;
-     unsigned long disp_cg_ok2switch_en : 1;
-     unsigned long sclk_force_reg       : 1;
-     unsigned long sclk_force_disp      : 1;
-     unsigned long sclk_force_mc        : 1;
-     unsigned long sclk_force_extmc     : 1;
-     unsigned long sclk_force_cp        : 1;
-     unsigned long sclk_force_e2        : 1;
-     unsigned long sclk_force_e3        : 1;
-     unsigned long sclk_force_idct      : 1;
-     unsigned long sclk_force_bist      : 1;
-     unsigned long busy_extend_cp       : 1;
-     unsigned long busy_extend_e2       : 1;
-     unsigned long busy_extend_e3       : 1;
-     unsigned long busy_extend_idct     : 1;
-     unsigned long                                      : 3;
+        unsigned long sclk_src_sel         : 2;
+        unsigned long                      : 2;
+        unsigned long sclk_post_div_fast   : 4;
+        unsigned long sclk_clkon_hys       : 3;
+        unsigned long sclk_post_div_slow   : 4;
+        unsigned long disp_cg_ok2switch_en : 1;
+        unsigned long sclk_force_reg       : 1;
+        unsigned long sclk_force_disp      : 1;
+        unsigned long sclk_force_mc        : 1;
+        unsigned long sclk_force_extmc     : 1;
+        unsigned long sclk_force_cp        : 1;
+        unsigned long sclk_force_e2        : 1;
+        unsigned long sclk_force_e3        : 1;
+        unsigned long sclk_force_idct      : 1;
+        unsigned long sclk_force_bist      : 1;
+        unsigned long busy_extend_cp       : 1;
+        unsigned long busy_extend_e2       : 1;
+        unsigned long busy_extend_e3       : 1;
+        unsigned long busy_extend_idct     : 1;
+        unsigned long                      : 3;
 } __attribute__((packed));
 
 union sclk_cntl_u {
-     unsigned long val : 32;
-     struct sclk_cntl_t f;
+        unsigned long val : 32;
+        struct sclk_cntl_t f;
 } __attribute__((packed));
 
 struct pclk_cntl_t {
-     unsigned long pclk_src_sel     : 2;
-     unsigned long                              : 2;
-     unsigned long pclk_post_div    : 4;
-     unsigned long                              : 8;
-     unsigned long pclk_force_disp  : 1;
-     unsigned long                              : 15;
+        unsigned long pclk_src_sel     : 2;
+        unsigned long                  : 2;
+        unsigned long pclk_post_div    : 4;
+        unsigned long                  : 8;
+        unsigned long pclk_force_disp  : 1;
+        unsigned long                  : 15;
 } __attribute__((packed));
 
 union pclk_cntl_u {
-     unsigned long val : 32;
-     struct pclk_cntl_t f;
+        unsigned long val : 32;
+        struct pclk_cntl_t f;
 } __attribute__((packed));
 
+
+#define TESTCLK_SRC_PLL   0x01
+#define TESTCLK_SRC_SCLK  0x02
+#define TESTCLK_SRC_PCLK  0x03
+/* 4 and 5 seem to by XTAL/M */
+#define TESTCLK_SRC_XTAL  0x06
+
 struct clk_test_cntl_t {
-     unsigned long testclk_sel      : 4;
-     unsigned long                              : 3;
-     unsigned long start_check_freq : 1;
-     unsigned long tstcount_rst     : 1;
-     unsigned long                              : 15;
-     unsigned long test_count       : 8;
+        unsigned long testclk_sel      : 4;
+        unsigned long                  : 3;
+        unsigned long start_check_freq : 1;
+        unsigned long tstcount_rst     : 1;
+        unsigned long                  : 15;
+        unsigned long test_count       : 8;
 } __attribute__((packed));
 
 union clk_test_cntl_u {
-     unsigned long val : 32;
-     struct clk_test_cntl_t f;
+        unsigned long val : 32;
+        struct clk_test_cntl_t f;
 } __attribute__((packed));
 
 struct pwrmgt_cntl_t {
-     unsigned long pwm_enable           : 1;
-     unsigned long                                      : 1;
-     unsigned long pwm_mode_req         : 2;
-     unsigned long pwm_wakeup_cond      : 2;
-     unsigned long pwm_fast_noml_hw_en  : 1;
-     unsigned long pwm_noml_fast_hw_en  : 1;
-     unsigned long pwm_fast_noml_cond   : 4;
-     unsigned long pwm_noml_fast_cond   : 4;
-     unsigned long pwm_idle_timer       : 8;
-     unsigned long pwm_busy_timer       : 8;
+        unsigned long pwm_enable           : 1;
+        unsigned long                      : 1;
+        unsigned long pwm_mode_req         : 2;
+        unsigned long pwm_wakeup_cond      : 2;
+        unsigned long pwm_fast_noml_hw_en  : 1;
+        unsigned long pwm_noml_fast_hw_en  : 1;
+        unsigned long pwm_fast_noml_cond   : 4;
+        unsigned long pwm_noml_fast_cond   : 4;
+        unsigned long pwm_idle_timer       : 8;
+        unsigned long pwm_busy_timer       : 8;
 } __attribute__((packed));
 
 union pwrmgt_cntl_u {
-     unsigned long val : 32;
-     struct pwrmgt_cntl_t f;
+        unsigned long val : 32;
+        struct pwrmgt_cntl_t f;
 } __attribute__((packed));
 
 #endif