74 files changed, 1694 insertions, 1928 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 0cce28c4025b..33e2ca847a26 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -247,7 +247,7 @@ config ACPI_CUSTOM_DSDT_FILE
           Enter the full path name to the file wich includes the AmlCode declaration.
 
 config ACPI_BLACKLIST_YEAR
-        int "Disable ACPI for systems before Jan 1st this year" if X86
+        int "Disable ACPI for systems before Jan 1st this year" if X86_32
         default 0
         help
           enter a 4-digit year, eg. 2001 to disable ACPI by default
@@ -285,9 +285,8 @@ config ACPI_SYSTEM
           dump your ACPI DSDT table using /proc/acpi/dsdt.
 
 config X86_PM_TIMER
-        bool "Power Management Timer Support"
+        bool "Power Management Timer Support" if EMBEDDED
         depends on X86
-        depends on !X86_64
         default y
         help
           The Power Management Timer is available on all ACPI-capable,
@@ -298,9 +297,8 @@ config X86_PM_TIMER
           voltage scaling, unlike the commonly used Time Stamp Counter
           (TSC) timing source.
 
-          So, if you see messages like 'Losing too many ticks!' in the
-          kernel logs, and/or you are using this on a notebook which
-          does not yet have an HPET, you should say "Y" here.
+          You should nearly always say Y here because many modern
+          systems require this timer. 
 
 config ACPI_CONTAINER
         tristate "ACPI0004,PNP0A05 and PNP0A06 Container Driver (EXPERIMENTAL)"
diff --git a/drivers/acpi/resources/rscalc.c b/drivers/acpi/resources/rscalc.c
index 7d6481d9fbec..4038dbfa63a0 100644
--- a/drivers/acpi/resources/rscalc.c
+++ b/drivers/acpi/resources/rscalc.c
@@ -391,8 +391,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
                          * Ensure a 32-bit boundary for the structure
                          */
                         extra_struct_bytes =
-                            ACPI_ROUND_UP_to_32_bITS(resource_length) -
-                            resource_length;
+                            ACPI_ROUND_UP_to_32_bITS(resource_length);
                         break;
 
                 case ACPI_RESOURCE_NAME_END_TAG:
@@ -408,8 +407,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
                          * Add vendor data and ensure a 32-bit boundary for the structure
                          */
                         extra_struct_bytes =
-                            ACPI_ROUND_UP_to_32_bITS(resource_length) -
-                            resource_length;
+                            ACPI_ROUND_UP_to_32_bITS(resource_length);
                         break;
 
                 case ACPI_RESOURCE_NAME_ADDRESS32:
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 93e44d0292ab..bc9b2bcd7dba 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -58,6 +58,7 @@
 #include <linux/suspend.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_ioctl.h>
+#include <scsi/scsi.h>
 
 #include <asm/uaccess.h>
 
@@ -380,6 +381,7 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
         memcpy(rq->cmd, cgc->cmd, CDROM_PACKET_SIZE);
         if (sizeof(rq->cmd) > CDROM_PACKET_SIZE)
                 memset(rq->cmd + CDROM_PACKET_SIZE, 0, sizeof(rq->cmd) - CDROM_PACKET_SIZE);
+        rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
 
         rq->ref_count++;
         rq->flags |= REQ_NOMERGE;
@@ -1495,40 +1497,42 @@ static int pkt_set_write_settings(struct pktcdvd_device *pd)
 }
 
 /*
- * 0 -- we can write to this track, 1 -- we can't
+ * 1 -- we can write to this track, 0 -- we can't
  */
-static int pkt_good_track(track_information *ti)
+static int pkt_writable_track(struct pktcdvd_device *pd, track_information *ti)
 {
-        /*
-         * only good for CD-RW at the moment, not DVD-RW
-         */
+        switch (pd->mmc3_profile) {
+                case 0x1a: /* DVD+RW */
+                case 0x12: /* DVD-RAM */
+                        /* The track is always writable on DVD+RW/DVD-RAM */
+                        return 1;
+                default:
+                        break;
+        }
 
-        /*
-         * FIXME: only for FP
-         */
-        if (ti->fp == 0)
+        if (!ti->packet || !ti->fp)
                 return 0;
 
         /*
          * "good" settings as per Mt Fuji.
          */
-        if (ti->rt == 0 && ti->blank == 0 && ti->packet == 1)
-                return 0;
+        if (ti->rt == 0 && ti->blank == 0)
+                return 1;
 
-        if (ti->rt == 0 && ti->blank == 1 && ti->packet == 1)
-                return 0;
+        if (ti->rt == 0 && ti->blank == 1)
+                return 1;
 
-        if (ti->rt == 1 && ti->blank == 0 && ti->packet == 1)
-                return 0;
+        if (ti->rt == 1 && ti->blank == 0)
+                return 1;
 
         printk("pktcdvd: bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet);
-        return 1;
+        return 0;
 }
 
 /*
- * 0 -- we can write to this disc, 1 -- we can't
+ * 1 -- we can write to this disc, 0 -- we can't
  */
-static int pkt_good_disc(struct pktcdvd_device *pd, disc_information *di)
+static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
 {
         switch (pd->mmc3_profile) {
                 case 0x0a: /* CD-RW */
@@ -1537,10 +1541,10 @@ static int pkt_good_disc(struct pktcdvd_device *pd, disc_information *di)
                 case 0x1a: /* DVD+RW */
                 case 0x13: /* DVD-RW */
                 case 0x12: /* DVD-RAM */
-                        return 0;
+                        return 1;
                 default:
                         VPRINTK("pktcdvd: Wrong disc profile (%x)\n", pd->mmc3_profile);
-                        return 1;
+                        return 0;
         }
 
         /*
@@ -1549,25 +1553,25 @@ static int pkt_good_disc(struct pktcdvd_device *pd, disc_information *di)
          */
         if (di->disc_type == 0xff) {
                 printk("pktcdvd: Unknown disc. No track?\n");
-                return 1;
+                return 0;
         }
 
         if (di->disc_type != 0x20 && di->disc_type != 0) {
                 printk("pktcdvd: Wrong disc type (%x)\n", di->disc_type);
-                return 1;
+                return 0;
         }
 
         if (di->erasable == 0) {
                 printk("pktcdvd: Disc not erasable\n");
-                return 1;
+                return 0;
         }
 
         if (di->border_status == PACKET_SESSION_RESERVED) {
                 printk("pktcdvd: Can't write to last track (reserved)\n");
-                return 1;
+                return 0;
         }
 
-        return 0;
+        return 1;
 }
 
 static int pkt_probe_settings(struct pktcdvd_device *pd)
@@ -1592,23 +1596,9 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
                 return ret;
         }
 
-        if (pkt_good_disc(pd, &di))
-                return -ENXIO;
+        if (!pkt_writable_disc(pd, &di))
+                return -EROFS;
 
-        switch (pd->mmc3_profile) {
-                case 0x1a: /* DVD+RW */
-                        printk("pktcdvd: inserted media is DVD+RW\n");
-                        break;
-                case 0x13: /* DVD-RW */
-                        printk("pktcdvd: inserted media is DVD-RW\n");
-                        break;
-                case 0x12: /* DVD-RAM */
-                        printk("pktcdvd: inserted media is DVD-RAM\n");
-                        break;
-                default:
-                        printk("pktcdvd: inserted media is CD-R%s\n", di.erasable ? "W" : "");
-                        break;
-        }
         pd->type = di.erasable ? PACKET_CDRW : PACKET_CDR;
 
         track = 1; /* (di.last_track_msb << 8) | di.last_track_lsb; */
@@ -1617,9 +1607,9 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
                 return ret;
         }
 
-        if (pkt_good_track(&ti)) {
+        if (!pkt_writable_track(pd, &ti)) {
                 printk("pktcdvd: can't write to this track\n");
-                return -ENXIO;
+                return -EROFS;
         }
 
         /*
@@ -1633,7 +1623,7 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
         }
         if (pd->settings.size > PACKET_MAX_SECTORS) {
                 printk("pktcdvd: packet size is too big\n");
-                return -ENXIO;
+                return -EROFS;
         }
         pd->settings.fp = ti.fp;
         pd->offset = (be32_to_cpu(ti.track_start) << 2) & (pd->settings.size - 1);
@@ -1675,7 +1665,7 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
                         break;
                 default:
                         printk("pktcdvd: unknown data mode\n");
-                        return 1;
+                        return -EROFS;
         }
         return 0;
 }
@@ -1886,7 +1876,7 @@ static int pkt_open_write(struct pktcdvd_device *pd)
 
         if ((ret = pkt_probe_settings(pd))) {
                 VPRINTK("pktcdvd: %s failed probe\n", pd->name);
-                return -EROFS;
+                return ret;
         }
 
         if ((ret = pkt_set_write_settings(pd))) {
diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 486ed8a11b59..a4d425d2dce2 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -15,22 +15,23 @@ config AGP
           due to kernel allocation issues), you could use PCI accesses
           and have up to a couple gigs of texture space.
 
-          Note that this is the only means to have XFree4/GLX use
+          Note that this is the only means to have X/GLX use
           write-combining with MTRR support on the AGP bus. Without it, OpenGL
           direct rendering will be a lot slower but still faster than PIO.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
-
           To compile this driver as a module, choose M here: the
           module will be called agpgart.
 
+          You should say Y here if you want to use GLX or DRI.
+
+          If unsure, say N.
+
 config AGP_ALI
         tristate "ALI chipset support"
         depends on AGP && X86_32
         ---help---
           This option gives you AGP support for the GLX component of
-          XFree86 4.x on the following ALi chipsets.  The supported chipsets
+          X on the following ALi chipsets.  The supported chipsets
           include M1541, M1621, M1631, M1632, M1641,M1647,and M1651.
           For the ALi-chipset question, ALi suggests you refer to
           <http://www.ali.com.tw/eng/support/index.shtml>.
@@ -40,28 +41,19 @@ config AGP_ALI
           timing issues, this chipset cannot do AGP 2x with the G200.
           This is a hardware limitation. AGP 1x seems to be fine, though.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
-
 config AGP_ATI
         tristate "ATI chipset support"
         depends on AGP && X86_32
         ---help---
-      This option gives you AGP support for the GLX component of
-      XFree86 4.x on the ATI RadeonIGP family of chipsets.
-
-      You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-      use GLX or DRI.  If unsure, say N.
+          This option gives you AGP support for the GLX component of
+          X on the ATI RadeonIGP family of chipsets.
 
 config AGP_AMD
         tristate "AMD Irongate, 761, and 762 chipset support"
         depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
-          XFree86 4.x on AMD Irongate, 761, and 762 chipsets.
-
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
+          X on AMD Irongate, 761, and 762 chipsets.
 
 config AGP_AMD64
         tristate "AMD Opteron/Athlon64 on-CPU GART support" if !GART_IOMMU
@@ -69,45 +61,38 @@ config AGP_AMD64
         default y if GART_IOMMU
         help
           This option gives you AGP support for the GLX component of
-          XFree86 4.x using the on-CPU northbridge of the AMD Athlon64/Opteron CPUs.
+          X using the on-CPU northbridge of the AMD Athlon64/Opteron CPUs.
           You still need an external AGP bridge like the AMD 8151, VIA
           K8T400M, SiS755. It may also support other AGP bridges when loaded
           with agp_try_unsupported=1.
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say Y
 
 config AGP_INTEL
         tristate "Intel 440LX/BX/GX, I8xx and E7x05 chipset support"
         depends on AGP && X86
         help
-          This option gives you AGP support for the GLX component of XFree86 4.x
+          This option gives you AGP support for the GLX component of X
           on Intel 440LX/BX/GX, 815, 820, 830, 840, 845, 850, 860, 875,
-          E7205 and E7505 chipsets and full support for the 810, 815, 830M, 845G,
-          852GM, 855GM, 865G and I915 integrated graphics chipsets.
+          E7205 and E7505 chipsets and full support for the 810, 815, 830M,
+          845G, 852GM, 855GM, 865G and I915 integrated graphics chipsets.
+
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI, or if you have any Intel integrated graphics
-          chipsets.  If unsure, say Y.
 
 config AGP_NVIDIA
         tristate "NVIDIA nForce/nForce2 chipset support"
         depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
-          XFree86 4.x on the following NVIDIA chipsets.  The supported chipsets
-          include nForce and nForce2
+          X on NVIDIA chipsets including nForce and nForce2
 
 config AGP_SIS
         tristate "SiS chipset support"
         depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
-          XFree86 4.x on Silicon Integrated Systems [SiS] chipsets.
+          X on Silicon Integrated Systems [SiS] chipsets.
 
           Note that 5591/5592 AGP chipsets are NOT supported.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
 
 config AGP_SWORKS
         tristate "Serverworks LE/HE chipset support"
@@ -121,10 +106,7 @@ config AGP_VIA
         depends on AGP && X86_32
         help
           This option gives you AGP support for the GLX component of
-          XFree86 4.x on VIA MVP3/Apollo Pro chipsets.
-
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say N.
+          X on VIA MVP3/Apollo Pro chipsets.
 
 config AGP_I460
         tristate "Intel 460GX chipset support"
@@ -159,9 +141,6 @@ config AGP_EFFICEON
           This option gives you AGP support for the Transmeta Efficeon
           series processors with integrated northbridges.
 
-          You should say Y here if you use XFree86 3.3.6 or 4.x and want to
-          use GLX or DRI.  If unsure, say Y.
-
 config AGP_SGI_TIOCA
         tristate "SGI TIO chipset AGP support"
         depends on AGP && (IA64_SGI_SN2 || IA64_GENERIC)
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 9964c508c111..1251b2515bbe 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -516,8 +516,10 @@ static int __devinit nforce3_agp_init(struct pci_dev *pdev)
         pci_read_config_dword (hammers[0], AMD64_GARTAPERTUREBASE, &apbase);
 
         /* if x86-64 aperture base is beyond 4G, exit here */
-        if ( (apbase & 0x7fff) >> (32 - 25) )
-                 return -ENODEV;
+        if ( (apbase & 0x7fff) >> (32 - 25) ) {
+                printk(KERN_INFO PFX "aperture base > 4G\n");
+                return -ENODEV;
+        }
 
         apbase = (apbase & 0x7fff) << 25;
 
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index 268f78d926d3..efef9999f1cf 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -468,9 +468,7 @@ static int __devinit agp_serverworks_probe(struct pci_dev *pdev,
 
         switch (pdev->device) {
         case 0x0006:
-                /* ServerWorks CNB20HE
-                Fail silently.*/
-                printk (KERN_ERR PFX "Detected ServerWorks CNB20HE chipset: No AGP present.\n");
+                printk (KERN_ERR PFX "ServerWorks CNB20HE is unsupported due to lack of documentation.\n");
                 return -ENODEV;
 
         case PCI_DEVICE_ID_SERVERWORKS_HE:
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index a1381c61aa63..d3879ac9970f 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -202,10 +202,15 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
 void i915_driver_irq_uninstall(drm_device_t * dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        u16 temp;
+
         if (!dev_priv)
                 return;
 
         I915_WRITE16(I915REG_HWSTAM, 0xffff);
         I915_WRITE16(I915REG_INT_MASK_R, 0xffff);
         I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
+
+        temp = I915_READ16(I915REG_INT_IDENTITY_R);
+        I915_WRITE16(I915REG_INT_IDENTITY_R, temp);
 }
diff --git a/drivers/char/drm/r300_cmdbuf.c b/drivers/char/drm/r300_cmdbuf.c
index 291dbf4c8186..c08fa5076f05 100644
--- a/drivers/char/drm/r300_cmdbuf.c
+++ b/drivers/char/drm/r300_cmdbuf.c
@@ -161,6 +161,7 @@ void r300_init_reg_flags(void)
         ADD_RANGE(R300_VAP_PVS_CNTL_1, 3);
         ADD_RANGE(R300_GB_ENABLE, 1);
         ADD_RANGE(R300_GB_MSPOS0, 5);
+        ADD_RANGE(R300_TX_CNTL, 1);
         ADD_RANGE(R300_TX_ENABLE, 1);
         ADD_RANGE(0x4200, 4);
         ADD_RANGE(0x4214, 1);
@@ -489,6 +490,50 @@ static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
 
         return 0;
 }
+static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
+                                             drm_radeon_kcmd_buffer_t *cmdbuf)
+{
+        u32 *cmd = (u32 *) cmdbuf->buf;
+        int count, ret;
+        RING_LOCALS;
+
+        count=(cmd[0]>>16) & 0x3fff;
+
+        if (cmd[0] & 0x8000) {
+                u32 offset;
+
+                if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL 
+                              | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
+                        offset = cmd[2] << 10;
+                        ret = r300_check_offset(dev_priv, offset);
+                        if (ret) {
+                                DRM_ERROR("Invalid bitblt first offset is %08X\n", offset);
+                                return DRM_ERR(EINVAL);
+                        }
+                }
+
+                if ((cmd[1] & RADEON_GMC_SRC_PITCH_OFFSET_CNTL) &&
+                    (cmd[1] & RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
+                        offset = cmd[3] << 10;
+                        ret = r300_check_offset(dev_priv, offset);
+                        if (ret) {
+                                DRM_ERROR("Invalid bitblt second offset is %08X\n", offset);
+                                return DRM_ERR(EINVAL);
+                        }
+                        
+                }
+        }
+
+        BEGIN_RING(count+2);
+        OUT_RING(cmd[0]);
+        OUT_RING_TABLE((int *)(cmdbuf->buf + 4), count + 1);
+        ADVANCE_RING();
+
+        cmdbuf->buf += (count+2)*4;
+        cmdbuf->bufsz -= (count+2)*4;
+
+        return 0;
+}
 
 static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
                                             drm_radeon_kcmd_buffer_t *cmdbuf)
@@ -527,6 +572,9 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
         case RADEON_3D_LOAD_VBPNTR:     /* load vertex array pointers */
                 return r300_emit_3d_load_vbpntr(dev_priv, cmdbuf, header);
 
+        case RADEON_CNTL_BITBLT_MULTI:
+                return r300_emit_bitblt_multi(dev_priv, cmdbuf);
+
         case RADEON_CP_3D_DRAW_IMMD_2:  /* triggers drawing using in-packet vertex data */
         case RADEON_CP_3D_DRAW_VBUF_2:  /* triggers drawing of vertex buffers setup elsewhere */
         case RADEON_CP_3D_DRAW_INDX_2:  /* triggers drawing using indices to vertex buffer */
diff --git a/drivers/char/drm/r300_reg.h b/drivers/char/drm/r300_reg.h
index a0ed20e25221..d1e19954406b 100644
--- a/drivers/char/drm/r300_reg.h
+++ b/drivers/char/drm/r300_reg.h
@@ -451,6 +451,9 @@ I am fairly certain that they are correct unless stated otherwise in comments.
 /* END */
 
 /* gap */
+/* Zero to flush caches. */
+#define R300_TX_CNTL                        0x4100
+
 /* The upper enable bits are guessed, based on fglrx reported limits. */
 #define R300_TX_ENABLE                      0x4104
 #       define R300_TX_ENABLE_0                  (1 << 0)
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index 498b19b1d641..1f7d2ab8c4fc 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -90,9 +90,10 @@
  * 1.19- Add support for gart table in FB memory and PCIE r300
  * 1.20- Add support for r300 texrect
  * 1.21- Add support for card type getparam
+ * 1.22- Add support for texture cache flushes (R300_TX_CNTL)
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            21
+#define DRIVER_MINOR            22
 #define DRIVER_PATCHLEVEL       0
 
 /*
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 1994a92d4733..f65b2e14a485 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -335,6 +335,8 @@ static int hvc_open(struct tty_struct *tty, struct file * filp)
         } /* else count == 0 */
 
         tty->driver_data = hp;
+        tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
+
         hp->tty = tty;
         /* Save for request_irq outside of spin_lock. */
         irq = hp->irq;
@@ -633,9 +635,6 @@ static int hvc_poll(struct hvc_struct *hp)
                         tty_insert_flip_char(tty, buf[i], 0);
                 }
 
-                if (count)
-                        tty_schedule_flip(tty);
-
                 /*
                  * Account for the total amount read in one loop, and if above
                  * 64 bytes, we do a quick schedule loop to let the tty grok
@@ -656,6 +655,9 @@ static int hvc_poll(struct hvc_struct *hp)
  bail:
         spin_unlock_irqrestore(&hp->lock, flags);
 
+        if (read_total)
+                tty_flip_buffer_push(tty);
+        
         return poll_mask;
 }
 
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index c2490e270f1f..588e75ec1630 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -2173,15 +2173,17 @@ static int probe_si (struct sx_board *board)
         if ( IS_SI1_BOARD(board)) {
                 /* This should be an SI1 board, which has this
                    location writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
                         func_exit ();
                         return 0; 
+                }
         } else {
                 /* This should be an SI2 board, which has the bottom
                    3 bits non-writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
                         func_exit ();
                         return 0; 
+                }
         }
 
         /* Now we're pretty much convinced that there is an SI board here, 
@@ -2192,15 +2194,17 @@ static int probe_si (struct sx_board *board)
         if ( IS_SI1_BOARD(board)) {
                 /* This should be an SI1 board, which has this
                    location writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
                         func_exit();
                         return 0; 
+                }
         } else {
                 /* This should be an SI2 board, which has the bottom
                    3 bits non-writable... */
-                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10)
+                if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
                         func_exit ();
                         return 0; 
+                }
         }
 
         printheader ();
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 5765f672e853..d58f82318853 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -243,7 +243,7 @@ static struct sysrq_key_op sysrq_term_op = {
 
 static void moom_callback(void *ignored)
 {
-        out_of_memory(GFP_KERNEL, 0);
+        out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL], GFP_KERNEL, 0);
 }
 
 static DECLARE_WORK(moom_work, moom_callback, NULL);
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index ec7590951af5..24095f6ee6da 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -33,6 +33,7 @@
 static int TPM_INF_DATA;
 static int TPM_INF_ADDR;
 static int TPM_INF_BASE;
+static int TPM_INF_ADDR_LEN;
 static int TPM_INF_PORT_LEN;
 
 /* TPM header definitions */
@@ -195,6 +196,7 @@ static int tpm_inf_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         int i;
         int ret;
         u32 size = 0;
+        number_of_wtx = 0;
 
 recv_begin:
         /* start receiving header */
@@ -378,24 +380,35 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
         if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
             !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
                 TPM_INF_ADDR = pnp_port_start(dev, 0);
+                TPM_INF_ADDR_LEN = pnp_port_len(dev, 0);
                 TPM_INF_DATA = (TPM_INF_ADDR + 1);
                 TPM_INF_BASE = pnp_port_start(dev, 1);
                 TPM_INF_PORT_LEN = pnp_port_len(dev, 1);
-                if (!TPM_INF_PORT_LEN)
-                        return -EINVAL;
+                if ((TPM_INF_PORT_LEN < 4) || (TPM_INF_ADDR_LEN < 2)) {
+                        rc = -EINVAL;
+                        goto err_last;
+                }
                 dev_info(&dev->dev, "Found %s with ID %s\n",
                          dev->name, dev_id->id);
-                if (!((TPM_INF_BASE >> 8) & 0xff))
-                        return -EINVAL;
+                if (!((TPM_INF_BASE >> 8) & 0xff)) {
+                        rc = -EINVAL;
+                        goto err_last;
+                }
                 /* publish my base address and request region */
                 tpm_inf.base = TPM_INF_BASE;
                 if (request_region
                     (tpm_inf.base, TPM_INF_PORT_LEN, "tpm_infineon0") == NULL) {
-                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
-                        return -EINVAL;
+                        rc = -EINVAL;
+                        goto err_last;
+                }
+                if (request_region(TPM_INF_ADDR, TPM_INF_ADDR_LEN,
+                                "tpm_infineon0") == NULL) {
+                        rc = -EINVAL;
+                        goto err_last;
                 }
         } else {
-                return -EINVAL;
+                rc = -EINVAL;
+                goto err_last;
         }
 
         /* query chip for its vendor, its version number a.s.o. */
@@ -443,8 +456,8 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
                         dev_err(&dev->dev,
                                 "Could not set IO-ports to 0x%lx\n",
                                 tpm_inf.base);
-                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
-                        return -EIO;
+                        rc = -EIO;
+                        goto err_release_region;
                 }
 
                 /* activate register */
@@ -471,14 +484,21 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
 
                 rc = tpm_register_hardware(&dev->dev, &tpm_inf);
                 if (rc < 0) {
-                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
-                        return -ENODEV;
+                        rc = -ENODEV;
+                        goto err_release_region;
                 }
                 return 0;
         } else {
-                dev_info(&dev->dev, "No Infineon TPM found!\n");
-                return -ENODEV;
+                rc = -ENODEV;
+                goto err_release_region;
         }
+
+err_release_region:
+        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+        release_region(TPM_INF_ADDR, TPM_INF_ADDR_LEN);
+
+err_last:
+        return rc;
 }
 
 static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
@@ -518,5 +538,5 @@ module_exit(cleanup_inf);
 
 MODULE_AUTHOR("Marcel Selhorst <selhorst@crypto.rub.de>");
 MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
-MODULE_VERSION("1.6");
+MODULE_VERSION("1.7");
 MODULE_LICENSE("GPL");
diff --git a/drivers/crypto/padlock-aes.c b/drivers/crypto/padlock-aes.c
index 64819aa7cac4..0c08c58252be 100644
--- a/drivers/crypto/padlock-aes.c
+++ b/drivers/crypto/padlock-aes.c
@@ -348,10 +348,10 @@ aes_set_key(void *ctx_arg, const uint8_t *in_key, unsigned int key_len, uint32_t
                 break;
 
         case 32:
-                E_KEY[4] = le32_to_cpu(in_key[4]);
-                E_KEY[5] = le32_to_cpu(in_key[5]);
-                E_KEY[6] = le32_to_cpu(in_key[6]);
-                t = E_KEY[7] = le32_to_cpu(in_key[7]);
+                E_KEY[4] = le32_to_cpu(key[4]);
+                E_KEY[5] = le32_to_cpu(key[5]);
+                E_KEY[6] = le32_to_cpu(key[6]);
+                t = E_KEY[7] = le32_to_cpu(key[7]);
                 for (i = 0; i < 7; ++i)
                         loop8 (i);
                 break;
diff --git a/drivers/fc4/fc.c b/drivers/fc4/fc.c
index 5c8943509cc1..66d03f242d3c 100644
--- a/drivers/fc4/fc.c
+++ b/drivers/fc4/fc.c
@@ -1053,7 +1053,7 @@ static int fc_do_els(fc_channel *fc, unsigned int alpa, void *data, int len)
         int i;
 
         fcmd = &_fcmd;
-        memset(fcmd, 0, sizeof(fcmd));
+        memset(fcmd, 0, sizeof(fcp_cmnd));
         FCD(("PLOGI SID %d DID %d\n", fc->sid, alpa))
         fch = &fcmd->fch;
         FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, alpa);
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index 2b286e865163..43b96e298363 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -13,11 +13,6 @@
  * License along with this program; if not, write the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  *
- * Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
- * Mountain View, CA  94043, or:
- *
- * http://www.sgi.com
- *
  * For further information regarding this notice, see:
  *
  * http://oss.sgi.com/projects/GenInfo/NoticeExplan
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index 18d7eda38851..eca92eb475a1 100644
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -137,15 +137,15 @@ MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device (default = 1)"
 /*
  * SCSI inquiry hack for really badly behaved sbp2 devices. Turn this on
  * if your sbp2 device is not properly handling the SCSI inquiry command.
- * This hack makes the inquiry look more like a typical MS Windows
- * inquiry.
+ * This hack makes the inquiry look more like a typical MS Windows inquiry
+ * by enforcing 36 byte inquiry and avoiding access to mode_sense page 8.
  *
  * If force_inquiry_hack=1 is required for your device to work,
  * please submit the logged sbp2_firmware_revision value of this device to
  * the linux1394-devel mailing list.
  */
 static int force_inquiry_hack;
-module_param(force_inquiry_hack, int, 0444);
+module_param(force_inquiry_hack, int, 0644);
 MODULE_PARM_DESC(force_inquiry_hack, "Force SCSI inquiry hack (default = 0)");
 
 /*
@@ -264,18 +264,17 @@ static struct hpsb_protocol_driver sbp2_driver = {
         },
 };
 
-
-/* List of device firmware's that require a forced 36 byte inquiry.  */
+/*
+ * List of device firmwares that require the inquiry hack.
+ * Yields a few false positives but did not break other devices so far.
+ */
 static u32 sbp2_broken_inquiry_list[] = {
-        0x00002800,     /* Stefan Richter <richtest@bauwesen.tu-cottbus.de> */
+        0x00002800,     /* Stefan Richter <stefanr@s5r6.in-berlin.de> */
                         /* DViCO Momobay CX-1 */
         0x00000200      /* Andreas Plesch <plesch@fas.harvard.edu> */
                         /* QPS Fire DVDBurner */
 };
 
-#define NUM_BROKEN_INQUIRY_DEVS \
-        (sizeof(sbp2_broken_inquiry_list)/sizeof(*sbp2_broken_inquiry_list))
-
 /**************************************
  * General utility functions
  **************************************/
@@ -643,9 +642,15 @@ static int sbp2_remove(struct device *dev)
         if (!scsi_id)
                 return 0;
 
-        /* Trigger shutdown functions in scsi's highlevel. */
-        if (scsi_id->scsi_host)
+        if (scsi_id->scsi_host) {
+                /* Get rid of enqueued commands if there is no chance to
+                 * send them. */
+                if (!sbp2util_node_is_available(scsi_id))
+                        sbp2scsi_complete_all_commands(scsi_id, DID_NO_CONNECT);
+                /* scsi_remove_device() will trigger shutdown functions of SCSI
+                 * highlevel drivers which would deadlock if blocked. */
                 scsi_unblock_requests(scsi_id->scsi_host);
+        }
         sdev = scsi_id->sdev;
         if (sdev) {
                 scsi_id->sdev = NULL;
@@ -742,11 +747,6 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud
                 hi->host = ud->ne->host;
                 INIT_LIST_HEAD(&hi->scsi_ids);
 
-                /* Register our sbp2 status address space... */
-                hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host, &sbp2_ops,
-                                        SBP2_STATUS_FIFO_ADDRESS,
-                                        SBP2_STATUS_FIFO_ADDRESS +
-                                        SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(SBP2_MAX_UDS_PER_NODE+1));
 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
                 /* Handle data movement if physical dma is not
                  * enabled/supportedon host controller */
@@ -759,6 +759,18 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud
 
         list_add_tail(&scsi_id->scsi_list, &hi->scsi_ids);
 
+        /* Register the status FIFO address range. We could use the same FIFO
+         * for targets at different nodes. However we need different FIFOs per
+         * target in order to support multi-unit devices. */
+        scsi_id->status_fifo_addr = hpsb_allocate_and_register_addrspace(
+                        &sbp2_highlevel, ud->ne->host, &sbp2_ops,
+                        sizeof(struct sbp2_status_block), sizeof(quadlet_t),
+                        ~0ULL, ~0ULL);
+        if (!scsi_id->status_fifo_addr) {
+                SBP2_ERR("failed to allocate status FIFO address range");
+                goto failed_alloc;
+        }
+
         /* Register our host with the SCSI stack. */
         scsi_host = scsi_host_alloc(&scsi_driver_template,
                                     sizeof(unsigned long));
@@ -997,6 +1009,10 @@ static void sbp2_remove_device(struct scsi_id_instance_data *scsi_id)
                 SBP2_DMA_FREE("single query logins data");
         }
 
+        if (scsi_id->status_fifo_addr)
+                hpsb_unregister_addrspace(&sbp2_highlevel, hi->host,
+                        scsi_id->status_fifo_addr);
+
         scsi_id->ud->device.driver_data = NULL;
 
         SBP2_DEBUG("SBP-2 device removed, SCSI ID = %d", scsi_id->ud->id);
@@ -1075,11 +1091,10 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
                 ORB_SET_QUERY_LOGINS_RESP_LENGTH(sizeof(struct sbp2_query_logins_response));
         SBP2_DEBUG("sbp2_query_logins: reserved_resp_length initialized");
 
-        scsi_id->query_logins_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
-                                                    SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
-        scsi_id->query_logins_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
-                                                     SBP2_STATUS_FIFO_ADDRESS_HI);
-        SBP2_DEBUG("sbp2_query_logins: status FIFO initialized");
+        scsi_id->query_logins_orb->status_fifo_hi =
+                ORB_SET_STATUS_FIFO_HI(scsi_id->status_fifo_addr, hi->host->node_id);
+        scsi_id->query_logins_orb->status_fifo_lo =
+                ORB_SET_STATUS_FIFO_LO(scsi_id->status_fifo_addr);
 
         sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_orb, sizeof(struct sbp2_query_logins_orb));
 
@@ -1184,11 +1199,10 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
                 ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response));
         SBP2_DEBUG("sbp2_login_device: passwd_resp_lengths initialized");
 
-        scsi_id->login_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
-                                             SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
-        scsi_id->login_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
-                                              SBP2_STATUS_FIFO_ADDRESS_HI);
-        SBP2_DEBUG("sbp2_login_device: status FIFO initialized");
+        scsi_id->login_orb->status_fifo_hi =
+                ORB_SET_STATUS_FIFO_HI(scsi_id->status_fifo_addr, hi->host->node_id);
+        scsi_id->login_orb->status_fifo_lo =
+                ORB_SET_STATUS_FIFO_LO(scsi_id->status_fifo_addr);
 
         /*
          * Byte swap ORB if necessary
@@ -1301,10 +1315,10 @@ static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id)
         scsi_id->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
 
         scsi_id->logout_orb->reserved5 = 0x0;
-        scsi_id->logout_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
-                                              SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
-        scsi_id->logout_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
-                                               SBP2_STATUS_FIFO_ADDRESS_HI);
+        scsi_id->logout_orb->status_fifo_hi =
+                ORB_SET_STATUS_FIFO_HI(scsi_id->status_fifo_addr, hi->host->node_id);
+        scsi_id->logout_orb->status_fifo_lo =
+                ORB_SET_STATUS_FIFO_LO(scsi_id->status_fifo_addr);
 
         /*
          * Byte swap ORB if necessary
@@ -1366,10 +1380,10 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
         scsi_id->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
 
         scsi_id->reconnect_orb->reserved5 = 0x0;
-        scsi_id->reconnect_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
-                                                 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
-        scsi_id->reconnect_orb->status_FIFO_hi =
-                (ORB_SET_NODE_ID(hi->host->node_id) | SBP2_STATUS_FIFO_ADDRESS_HI);
+        scsi_id->reconnect_orb->status_fifo_hi =
+                ORB_SET_STATUS_FIFO_HI(scsi_id->status_fifo_addr, hi->host->node_id);
+        scsi_id->reconnect_orb->status_fifo_lo =
+                ORB_SET_STATUS_FIFO_LO(scsi_id->status_fifo_addr);
 
         /*
          * Byte swap ORB if necessary
@@ -1560,7 +1574,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
         /* Check for a blacklisted set of devices that require us to force
          * a 36 byte host inquiry. This can be overriden as a module param
          * (to force all hosts).  */
-        for (i = 0; i < NUM_BROKEN_INQUIRY_DEVS; i++) {
+        for (i = 0; i < ARRAY_SIZE(sbp2_broken_inquiry_list); i++) {
                 if ((firmware_revision & 0xffff00) ==
                                 sbp2_broken_inquiry_list[i]) {
                         SBP2_WARN("Node " NODE_BUS_FMT ": Using 36byte inquiry workaround",
@@ -2007,18 +2021,6 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id,
         }
 
         /*
-         * The scsi stack sends down a request_bufflen which does not match the
-         * length field in the scsi cdb. This causes some sbp2 devices to
-         * reject this inquiry command. Fix the request_bufflen.
-         */
-        if (*cmd == INQUIRY) {
-                if (force_inquiry_hack || scsi_id->workarounds & SBP2_BREAKAGE_INQUIRY_HACK)
-                        request_bufflen = cmd[4] = 0x24;
-                else
-                        request_bufflen = cmd[4];
-        }
-
-        /*
          * Now actually fill in the comamnd orb and sbp2 s/g list
          */
         sbp2_create_command_orb(scsi_id, command, cmd, SCpnt->use_sg,
@@ -2082,9 +2084,7 @@ static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id,
 
         SBP2_DEBUG("sbp2_check_sbp2_response");
 
-        switch (SCpnt->cmnd[0]) {
-
-        case INQUIRY:
+        if (SCpnt->cmnd[0] == INQUIRY && (SCpnt->cmnd[1] & 3) == 0) {
                 /*
                  * Make sure data length is ok. Minimum length is 36 bytes
                  */
@@ -2097,13 +2097,7 @@ static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id,
                  */
                 scsi_buf[2] |= 2;
                 scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2;
-
-                break;
-
-        default:
-                break;
         }
-        return;
 }
 
 /*
@@ -2114,7 +2108,6 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
 {
         struct sbp2scsi_host_info *hi;
         struct scsi_id_instance_data *scsi_id = NULL, *scsi_id_tmp;
-        u32 id;
         struct scsi_cmnd *SCpnt = NULL;
         u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
         struct sbp2_command_info *command;
@@ -2137,12 +2130,12 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
         }
 
         /*
-         * Find our scsi_id structure by looking at the status fifo address written to by
-         * the sbp2 device.
+         * Find our scsi_id structure by looking at the status fifo address
+         * written to by the sbp2 device.
          */
-        id = SBP2_STATUS_FIFO_OFFSET_TO_ENTRY((u32)(addr - SBP2_STATUS_FIFO_ADDRESS));
         list_for_each_entry(scsi_id_tmp, &hi->scsi_ids, scsi_list) {
-                if (scsi_id_tmp->ne->nodeid == nodeid && scsi_id_tmp->ud->id == id) {
+                if (scsi_id_tmp->ne->nodeid == nodeid &&
+                    scsi_id_tmp->status_fifo_addr == addr) {
                         scsi_id = scsi_id_tmp;
                         break;
                 }
@@ -2483,7 +2476,16 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
 
 static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
 {
-        ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = sdev;
+        struct scsi_id_instance_data *scsi_id =
+                (struct scsi_id_instance_data *)sdev->host->hostdata[0];
+
+        scsi_id->sdev = sdev;
+
+        if (force_inquiry_hack ||
+            scsi_id->workarounds & SBP2_BREAKAGE_INQUIRY_HACK) {
+                sdev->inquiry_len = 36;
+                sdev->skip_ms_page_8 = 1;
+        }
         return 0;
 }
 
diff --git a/drivers/ieee1394/sbp2.h b/drivers/ieee1394/sbp2.h
index 900ea1d25e71..e2d357a9ea3a 100644
--- a/drivers/ieee1394/sbp2.h
+++ b/drivers/ieee1394/sbp2.h
@@ -33,15 +33,17 @@
 #define ORB_DIRECTION_NO_DATA_TRANSFER  0x2
 
 #define ORB_SET_NULL_PTR(value)                 ((value & 0x1) << 31)
-#define ORB_SET_NOTIFY(value)                   ((value & 0x1) << 31)
-#define ORB_SET_RQ_FMT(value)                   ((value & 0x3) << 29)   /* unused ? */
+#define ORB_SET_NOTIFY(value)                   ((value & 0x1) << 31)
+#define ORB_SET_RQ_FMT(value)                   ((value & 0x3) << 29)   /* unused ? */
 #define ORB_SET_NODE_ID(value)                  ((value & 0xffff) << 16)
-#define ORB_SET_DATA_SIZE(value)                (value & 0xffff)
-#define ORB_SET_PAGE_SIZE(value)                ((value & 0x7) << 16)
-#define ORB_SET_PAGE_TABLE_PRESENT(value)       ((value & 0x1) << 19)
-#define ORB_SET_MAX_PAYLOAD(value)              ((value & 0xf) << 20)
-#define ORB_SET_SPEED(value)                    ((value & 0x7) << 24)
-#define ORB_SET_DIRECTION(value)                ((value & 0x1) << 27)
+#define ORB_SET_STATUS_FIFO_HI(value, id)       (value >> 32 | ORB_SET_NODE_ID(id))
+#define ORB_SET_STATUS_FIFO_LO(value)           (value & 0xffffffff)
+#define ORB_SET_DATA_SIZE(value)                (value & 0xffff)
+#define ORB_SET_PAGE_SIZE(value)                ((value & 0x7) << 16)
+#define ORB_SET_PAGE_TABLE_PRESENT(value)       ((value & 0x1) << 19)
+#define ORB_SET_MAX_PAYLOAD(value)              ((value & 0xf) << 20)
+#define ORB_SET_SPEED(value)                    ((value & 0x7) << 24)
+#define ORB_SET_DIRECTION(value)                ((value & 0x1) << 27)
 
 struct sbp2_command_orb {
         volatile u32 next_ORB_hi;
@@ -76,8 +78,8 @@ struct sbp2_login_orb {
         u32 login_response_lo;
         u32 lun_misc;
         u32 passwd_resp_lengths;
-        u32 status_FIFO_hi;
-        u32 status_FIFO_lo;
+        u32 status_fifo_hi;
+        u32 status_fifo_lo;
 };
 
 #define RESPONSE_GET_LOGIN_ID(value)            (value & 0xffff)
@@ -102,8 +104,8 @@ struct sbp2_query_logins_orb {
         u32 query_response_lo;
         u32 lun_misc;
         u32 reserved_resp_length;
-        u32 status_FIFO_hi;
-        u32 status_FIFO_lo;
+        u32 status_fifo_hi;
+        u32 status_fifo_lo;
 };
 
 #define RESPONSE_GET_MAX_LOGINS(value)          (value & 0xffff)
@@ -123,8 +125,8 @@ struct sbp2_reconnect_orb {
         u32 reserved4;
         u32 login_ID_misc;
         u32 reserved5;
-        u32 status_FIFO_hi;
-        u32 status_FIFO_lo;
+        u32 status_fifo_hi;
+        u32 status_fifo_lo;
 };
 
 struct sbp2_logout_orb {
@@ -134,8 +136,8 @@ struct sbp2_logout_orb {
         u32 reserved4;
         u32 login_ID_misc;
         u32 reserved5;
-        u32 status_FIFO_hi;
-        u32 status_FIFO_lo;
+        u32 status_fifo_hi;
+        u32 status_fifo_lo;
 };
 
 #define PAGE_TABLE_SET_SEGMENT_BASE_HI(value)   (value & 0xffff)
@@ -195,30 +197,6 @@ struct sbp2_status_block {
  * Miscellaneous SBP2 related config rom defines
  */
 
-/* The status fifo address definition below is used as a base for each
- * node, which a chunk seperately assigned to each unit directory in the
- * node.  For example, 0xfffe00000000ULL is used for the first sbp2 device
- * detected on node 0, 0xfffe00000020ULL for the next sbp2 device on node
- * 0, and so on.
- *
- * Note: We could use a single status fifo address for all sbp2 devices,
- * and figure out which sbp2 device the status belongs to by looking at
- * the source node id of the status write... but, using separate addresses
- * for each sbp2 unit directory allows for better code and the ability to
- * support multiple luns within a single 1394 node.
- *
- * Also note that we choose the address range below as it is a region
- * specified for write posting, where the ohci controller will
- * automatically send an ack_complete when the status is written by the
- * sbp2 device... saving a split transaction.   =)
- */
-#define SBP2_STATUS_FIFO_ADDRESS                                0xfffe00000000ULL
-#define SBP2_STATUS_FIFO_ADDRESS_HI                             0xfffe
-#define SBP2_STATUS_FIFO_ADDRESS_LO                             0x0
-
-#define SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(entry)                 ((entry) << 5)
-#define SBP2_STATUS_FIFO_OFFSET_TO_ENTRY(offset)                ((offset) >> 5)
-
 #define SBP2_UNIT_DIRECTORY_OFFSET_KEY                          0xd1
 #define SBP2_CSR_OFFSET_KEY                                     0x54
 #define SBP2_UNIT_SPEC_ID_KEY                                   0x12
@@ -258,7 +236,6 @@ struct sbp2_status_block {
  */
 
 #define SBP2_MAX_SG_ELEMENT_LENGTH      0xf000
-#define SBP2_MAX_UDS_PER_NODE           16      /* Maximum scsi devices per node */
 #define SBP2_MAX_SECTORS                255     /* Max sectors supported */
 #define SBP2_MAX_CMDS                   8       /* This should be safe */
 
@@ -338,6 +315,11 @@ struct scsi_id_instance_data {
         u32 sbp2_firmware_revision;
 
         /*
+         * Address for the device to write status blocks to
+         */
+        u64 status_fifo_addr;
+
+        /*
          * Variable used for logins, reconnects, logouts, query logins
          */
         atomic_t sbp2_login_complete;
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index 3a32c59494f2..24e51d5e97fc 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -151,6 +151,7 @@ struct smu_sdbp_header *smu_sat_get_sdb_partition(unsigned int sat_id, int id,
         kfree(buf);
         return NULL;
 }
+EXPORT_SYMBOL_GPL(smu_sat_get_sdb_partition);
 
 /* refresh the cache */
 static int wf_sat_read_cache(struct wf_sat *sat)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index e9adeb9d172f..745ca1f67b14 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -849,10 +849,16 @@ static struct mapped_device *alloc_dev(unsigned int minor, int persistent)
 
 static void free_dev(struct mapped_device *md)
 {
-        free_minor(md->disk->first_minor);
+        unsigned int minor = md->disk->first_minor;
+
+        if (md->suspended_bdev) {
+                thaw_bdev(md->suspended_bdev, NULL);
+                bdput(md->suspended_bdev);
+        }
         mempool_destroy(md->tio_pool);
         mempool_destroy(md->io_pool);
         del_gendisk(md->disk);
+        free_minor(minor);
         put_disk(md->disk);
         blk_put_queue(md->queue);
         kfree(md);
diff --git a/drivers/mmc/mmci.c b/drivers/mmc/mmci.c
index 37ee7f8dc82f..9fef29d978b5 100644
--- a/drivers/mmc/mmci.c
+++ b/drivers/mmc/mmci.c
@@ -97,6 +97,13 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         if (data->flags & MMC_DATA_READ) {
                 datactrl |= MCI_DPSM_DIRECTION;
                 irqmask = MCI_RXFIFOHALFFULLMASK;
+
+                /*
+                 * If we have less than a FIFOSIZE of bytes to transfer,
+                 * trigger a PIO interrupt as soon as any data is available.
+                 */
+                if (host->size < MCI_FIFOSIZE)
+                        irqmask |= MCI_RXDATAAVLBLMASK;
         } else {
                 /*
                  * We don't actually need to include "FIFO empty" here
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 69c04945591f..1c074d63ff3a 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -408,6 +408,7 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
                 cfi->chips[i].buffer_write_time = 1<<cfi->cfiq->BufWriteTimeoutTyp;
                 cfi->chips[i].erase_time = 1<<cfi->cfiq->BlockEraseTimeoutTyp;
                 cfi->chips[i].ref_point_counter = 0;
+                init_waitqueue_head(&(cfi->chips[i].wq));
         }
 
         map->fldrv = &cfi_intelext_chipdrv;
@@ -1019,8 +1020,8 @@ static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
 #define XIP_INVAL_CACHED_RANGE(map, from, size)  \
         INVALIDATE_CACHED_RANGE(map, from, size)
 
-#define INVALIDATE_CACHE_UDELAY(map, chip, adr, len, usec)  \
-        UDELAY(map, chip, adr, usec)
+#define INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr, adr, len, usec)  \
+        UDELAY(map, chip, cmd_adr, usec)
 
 /*
  * Extra notes:
@@ -1052,7 +1053,7 @@ do {  \
         spin_lock(chip->mutex);  \
 } while (0)
 
-#define INVALIDATE_CACHE_UDELAY(map, chip, adr, len, usec)  \
+#define INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr, adr, len, usec)  \
 do {  \
         spin_unlock(chip->mutex);  \
         INVALIDATE_CACHED_RANGE(map, adr, len);  \
@@ -1284,7 +1285,7 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
         map_write(map, datum, adr);
         chip->state = mode;
 
-        INVALIDATE_CACHE_UDELAY(map, chip,
+        INVALIDATE_CACHE_UDELAY(map, chip, adr,
                                 adr, map_bankwidth(map),
                                 chip->word_write_time);
 
@@ -1572,8 +1573,8 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
         map_write(map, CMD(0xd0), cmd_adr);
         chip->state = FL_WRITING;
 
-        INVALIDATE_CACHE_UDELAY(map, chip,
-                                cmd_adr, len,
+        INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr,
+                                adr, len,
                                 chip->buffer_write_time);
 
         timeo = jiffies + (HZ/2);
@@ -1744,7 +1745,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
         chip->state = FL_ERASING;
         chip->erase_suspended = 0;
 
-        INVALIDATE_CACHE_UDELAY(map, chip,
+        INVALIDATE_CACHE_UDELAY(map, chip, adr,
                                 adr, len,
                                 chip->erase_time*1000/2);
 
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 47c72a63dfe1..e45a8f959719 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2020,8 +2020,8 @@ config SIS190
           will be called sis190.  This is recommended.
 
 config SKGE
-        tristate "New SysKonnect GigaEthernet support (EXPERIMENTAL)"
-        depends on PCI && EXPERIMENTAL
+        tristate "New SysKonnect GigaEthernet support"
+        depends on PCI
         select CRC32
         ---help---
           This driver support the Marvell Yukon or SysKonnect SK-98xx/SK-95xx
@@ -2082,7 +2082,6 @@ config SK98LIN
             - Allied Telesyn AT-2971SX Gigabit Ethernet Adapter
             - Allied Telesyn AT-2971T Gigabit Ethernet Adapter
             - Belkin Gigabit Desktop Card 10/100/1000Base-T Adapter, Copper RJ-45
-            - DGE-530T Gigabit Ethernet Adapter
             - EG1032 v2 Instant Gigabit Network Adapter
             - EG1064 v2 Instant Gigabit Network Adapter
             - Marvell 88E8001 Gigabit LOM Ethernet Adapter (Abit)
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index e0f51afec778..bcf9f17daf0d 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1581,6 +1581,7 @@ int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
                 printk(KERN_INFO DRV_NAME
                        ": %s: %s not enslaved\n",
                        bond_dev->name, slave_dev->name);
+                write_unlock_bh(&bond->lock);
                 return -EINVAL;
         }
 
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 3682ec61e8a8..e7fc28b07e5a 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -102,6 +102,9 @@
  *      0.47: 26 Oct 2005: Add phyaddr 0 in phy scan.
  *      0.48: 24 Dec 2005: Disable TSO, bugfix for pci_map_single
  *      0.49: 10 Dec 2005: Fix tso for large buffers.
+ *      0.50: 20 Jan 2006: Add 8021pq tagging support.
+ *      0.51: 20 Jan 2006: Add 64bit consistent memory allocation for rings.
+ *      0.52: 20 Jan 2006: Add MSI/MSIX support.
  *
  * Known bugs:
  * We suspect that on some hardware no TX done interrupts are generated.
@@ -113,7 +116,7 @@
  * DEV_NEED_TIMERIRQ will not harm you on sane hardware, only generating a few
  * superfluous timer interrupts from the nic.
  */
-#define FORCEDETH_VERSION               "0.49"
+#define FORCEDETH_VERSION               "0.52"
 #define DRV_NAME                        "forcedeth"
 
 #include <linux/module.h>
@@ -153,6 +156,9 @@
 #define DEV_HAS_LARGEDESC       0x0004  /* device supports jumbo frames and needs packet format 2 */
 #define DEV_HAS_HIGH_DMA        0x0008  /* device supports 64bit dma */
 #define DEV_HAS_CHECKSUM        0x0010  /* device supports tx and rx checksum offloads */
+#define DEV_HAS_VLAN            0x0020  /* device supports vlan tagging and striping */
+#define DEV_HAS_MSI             0x0040  /* device supports MSI */
+#define DEV_HAS_MSI_X           0x0080  /* device supports MSI-X */
 
 enum {
         NvRegIrqStatus = 0x000,
@@ -166,14 +172,17 @@ enum {
 #define NVREG_IRQ_TX_OK                 0x0010
 #define NVREG_IRQ_TIMER                 0x0020
 #define NVREG_IRQ_LINK                  0x0040
-#define NVREG_IRQ_TX_ERROR              0x0080
-#define NVREG_IRQ_TX1                   0x0100
+#define NVREG_IRQ_RX_FORCED             0x0080
+#define NVREG_IRQ_TX_FORCED             0x0100
 #define NVREG_IRQMASK_THROUGHPUT        0x00df
 #define NVREG_IRQMASK_CPU               0x0040
+#define NVREG_IRQ_TX_ALL                (NVREG_IRQ_TX_ERR|NVREG_IRQ_TX_OK|NVREG_IRQ_TX_FORCED)
+#define NVREG_IRQ_RX_ALL                (NVREG_IRQ_RX_ERROR|NVREG_IRQ_RX|NVREG_IRQ_RX_NOBUF|NVREG_IRQ_RX_FORCED)
+#define NVREG_IRQ_OTHER                 (NVREG_IRQ_TIMER|NVREG_IRQ_LINK)
 
 #define NVREG_IRQ_UNKNOWN       (~(NVREG_IRQ_RX_ERROR|NVREG_IRQ_RX|NVREG_IRQ_RX_NOBUF|NVREG_IRQ_TX_ERR| \
-                                        NVREG_IRQ_TX_OK|NVREG_IRQ_TIMER|NVREG_IRQ_LINK|NVREG_IRQ_TX_ERROR| \
-                                        NVREG_IRQ_TX1))
+                                        NVREG_IRQ_TX_OK|NVREG_IRQ_TIMER|NVREG_IRQ_LINK|NVREG_IRQ_RX_FORCED| \
+                                        NVREG_IRQ_TX_FORCED))
 
         NvRegUnknownSetupReg6 = 0x008,
 #define NVREG_UNKSETUP6_VAL             3
@@ -185,6 +194,10 @@ enum {
         NvRegPollingInterval = 0x00c,
 #define NVREG_POLL_DEFAULT_THROUGHPUT   970
 #define NVREG_POLL_DEFAULT_CPU  13
+        NvRegMSIMap0 = 0x020,
+        NvRegMSIMap1 = 0x024,
+        NvRegMSIIrqMask = 0x030,
+#define NVREG_MSI_VECTOR_0_ENABLED 0x01
         NvRegMisc1 = 0x080,
 #define NVREG_MISC1_HD          0x02
 #define NVREG_MISC1_FORCE       0x3b0f3c
@@ -254,6 +267,10 @@ enum {
 #define NVREG_TXRXCTL_DESC_1    0
 #define NVREG_TXRXCTL_DESC_2    0x02100
 #define NVREG_TXRXCTL_DESC_3    0x02200
+#define NVREG_TXRXCTL_VLANSTRIP 0x00040
+#define NVREG_TXRXCTL_VLANINS   0x00080
+        NvRegTxRingPhysAddrHigh = 0x148,
+        NvRegRxRingPhysAddrHigh = 0x14C,
         NvRegMIIStatus = 0x180,
 #define NVREG_MIISTAT_ERROR             0x0001
 #define NVREG_MIISTAT_LINKCHANGE        0x0008
@@ -303,6 +320,11 @@ enum {
 #define NVREG_POWERSTATE_D1             0x0001
 #define NVREG_POWERSTATE_D2             0x0002
 #define NVREG_POWERSTATE_D3             0x0003
+        NvRegVlanControl = 0x300,
+#define NVREG_VLANCONTROL_ENABLE        0x2000
+        NvRegMSIXMap0 = 0x3e0,
+        NvRegMSIXMap1 = 0x3e4,
+        NvRegMSIXIrqStatus = 0x3f0,
 };
 
 /* Big endian: should work, but is untested */
@@ -314,7 +336,7 @@ struct ring_desc {
 struct ring_desc_ex {
         u32 PacketBufferHigh;
         u32 PacketBufferLow;
-        u32 Reserved;
+        u32 TxVlan;
         u32 FlagLen;
 };
 
@@ -355,6 +377,8 @@ typedef union _ring_type {
 #define NV_TX2_CHECKSUM_L3      (1<<27)
 #define NV_TX2_CHECKSUM_L4      (1<<26)
 
+#define NV_TX3_VLAN_TAG_PRESENT (1<<18)
+
 #define NV_RX_DESCRIPTORVALID   (1<<16)
 #define NV_RX_MISSEDFRAME       (1<<17)
 #define NV_RX_SUBSTRACT1        (1<<18)
@@ -385,6 +409,9 @@ typedef union _ring_type {
 #define NV_RX2_ERROR            (1<<30)
 #define NV_RX2_AVAIL            (1<<31)
 
+#define NV_RX3_VLAN_TAG_PRESENT (1<<16)
+#define NV_RX3_VLAN_TAG_MASK    (0x0000FFFF)
+
 /* Miscelaneous hardware related defines: */
 #define NV_PCI_REGSZ            0x270
 
@@ -475,6 +502,18 @@ typedef union _ring_type {
 #define LPA_1000FULL    0x0800
 #define LPA_1000HALF    0x0400
 
+/* MSI/MSI-X defines */
+#define NV_MSI_X_MAX_VECTORS  8
+#define NV_MSI_X_VECTORS_MASK 0x000f
+#define NV_MSI_CAPABLE        0x0010
+#define NV_MSI_X_CAPABLE      0x0020
+#define NV_MSI_ENABLED        0x0040
+#define NV_MSI_X_ENABLED      0x0080
+
+#define NV_MSI_X_VECTOR_ALL   0x0
+#define NV_MSI_X_VECTOR_RX    0x0
+#define NV_MSI_X_VECTOR_TX    0x1
+#define NV_MSI_X_VECTOR_OTHER 0x2
 
 /*
  * SMP locking:
@@ -511,6 +550,7 @@ struct fe_priv {
         u32 irqmask;
         u32 desc_ver;
         u32 txrxctl_bits;
+        u32 vlanctl_bits;
 
         void __iomem *base;
 
@@ -525,6 +565,7 @@ struct fe_priv {
         unsigned int pkt_limit;
         struct timer_list oom_kick;
         struct timer_list nic_poll;
+        u32 nic_poll_irq;
 
         /* media detection workaround.
          * Locking: Within irq hander or disable_irq+spin_lock(&np->lock);
@@ -540,6 +581,13 @@ struct fe_priv {
         dma_addr_t tx_dma[TX_RING];
         unsigned int tx_dma_len[TX_RING];
         u32 tx_flags;
+
+        /* vlan fields */
+        struct vlan_group *vlangrp;
+
+        /* msi/msi-x fields */
+        u32 msi_flags;
+        struct msix_entry msi_x_entry[NV_MSI_X_MAX_VECTORS];
 };
 
 /*
@@ -567,6 +615,16 @@ static int optimization_mode = NV_OPTIMIZATION_MODE_THROUGHPUT;
  */
 static int poll_interval = -1;
 
+/*
+ * Disable MSI interrupts
+ */
+static int disable_msi = 0;
+
+/*
+ * Disable MSIX interrupts
+ */
+static int disable_msix = 0;
+
 static inline struct fe_priv *get_nvpriv(struct net_device *dev)
 {
         return netdev_priv(dev);
@@ -612,6 +670,33 @@ static int reg_delay(struct net_device *dev, int offset, u32 mask, u32 target,
         return 0;
 }
 
+#define NV_SETUP_RX_RING 0x01
+#define NV_SETUP_TX_RING 0x02
+
+static void setup_hw_rings(struct net_device *dev, int rxtx_flags)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+
+        if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) {
+                if (rxtx_flags & NV_SETUP_RX_RING) {
+                        writel((u32) cpu_to_le64(np->ring_addr), base + NvRegRxRingPhysAddr);
+                }
+                if (rxtx_flags & NV_SETUP_TX_RING) {
+                        writel((u32) cpu_to_le64(np->ring_addr + RX_RING*sizeof(struct ring_desc)), base + NvRegTxRingPhysAddr);
+                }
+        } else {
+                if (rxtx_flags & NV_SETUP_RX_RING) {
+                        writel((u32) cpu_to_le64(np->ring_addr), base + NvRegRxRingPhysAddr);
+                        writel((u32) (cpu_to_le64(np->ring_addr) >> 32), base + NvRegRxRingPhysAddrHigh);
+                }
+                if (rxtx_flags & NV_SETUP_TX_RING) {
+                        writel((u32) cpu_to_le64(np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)), base + NvRegTxRingPhysAddr);
+                        writel((u32) (cpu_to_le64(np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)) >> 32), base + NvRegTxRingPhysAddrHigh);
+                }
+        }
+}
+
 #define MII_READ        (-1)
 /* mii_rw: read/write a register on the PHY.
  *
@@ -903,14 +988,27 @@ static void nv_do_rx_refill(unsigned long data)
         struct net_device *dev = (struct net_device *) data;
         struct fe_priv *np = netdev_priv(dev);
 
-        disable_irq(dev->irq);
+
+        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                disable_irq(dev->irq);
+        } else {
+                disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+        }
         if (nv_alloc_rx(dev)) {
                 spin_lock(&np->lock);
                 if (!np->in_shutdown)
                         mod_timer(&np->oom_kick, jiffies + OOM_REFILL);
                 spin_unlock(&np->lock);
         }
-        enable_irq(dev->irq);
+        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                enable_irq(dev->irq);
+        } else {
+                enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+        }
 }
 
 static void nv_init_rx(struct net_device *dev) 
@@ -965,7 +1063,7 @@ static int nv_release_txskb(struct net_device *dev, unsigned int skbnr)
         }
 
         if (np->tx_skbuff[skbnr]) {
-                dev_kfree_skb_irq(np->tx_skbuff[skbnr]);
+                dev_kfree_skb_any(np->tx_skbuff[skbnr]);
                 np->tx_skbuff[skbnr] = NULL;
                 return 1;
         } else {
@@ -1031,6 +1129,7 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
         u32 bcnt;
         u32 size = skb->len-skb->data_len;
         u32 entries = (size >> NV_TX2_TSO_MAX_SHIFT) + ((size & (NV_TX2_TSO_MAX_SIZE-1)) ? 1 : 0);
+        u32 tx_flags_vlan = 0;
 
         /* add fragments to entries count */
         for (i = 0; i < fragments; i++) {
@@ -1111,10 +1210,16 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
 #endif
         tx_flags_extra = (skb->ip_summed == CHECKSUM_HW ? (NV_TX2_CHECKSUM_L3|NV_TX2_CHECKSUM_L4) : 0);
 
+        /* vlan tag */
+        if (np->vlangrp && vlan_tx_tag_present(skb)) {
+                tx_flags_vlan = NV_TX3_VLAN_TAG_PRESENT | vlan_tx_tag_get(skb);
+        }
+
         /* set tx flags */
         if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) {
                 np->tx_ring.orig[start_nr].FlagLen |= cpu_to_le32(tx_flags | tx_flags_extra);
         } else {
+                np->tx_ring.ex[start_nr].TxVlan = cpu_to_le32(tx_flags_vlan);
                 np->tx_ring.ex[start_nr].FlagLen |= cpu_to_le32(tx_flags | tx_flags_extra);
         }       
 
@@ -1209,9 +1314,14 @@ static void nv_tx_timeout(struct net_device *dev)
 {
         struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
+        u32 status;
+
+        if (np->msi_flags & NV_MSI_X_ENABLED)
+                status = readl(base + NvRegMSIXIrqStatus) & NVREG_IRQSTAT_MASK;
+        else
+                status = readl(base + NvRegIrqStatus) & NVREG_IRQSTAT_MASK;
 
-        printk(KERN_INFO "%s: Got tx_timeout. irq: %08x\n", dev->name,
-                        readl(base + NvRegIrqStatus) & NVREG_IRQSTAT_MASK);
+        printk(KERN_INFO "%s: Got tx_timeout. irq: %08x\n", dev->name, status);
 
         {
                 int i;
@@ -1273,10 +1383,7 @@ static void nv_tx_timeout(struct net_device *dev)
                 printk(KERN_DEBUG "%s: tx_timeout: dead entries!\n", dev->name);
                 nv_drain_tx(dev);
                 np->next_tx = np->nic_tx = 0;
-                if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
-                        writel((u32) (np->ring_addr + RX_RING*sizeof(struct ring_desc)), base + NvRegTxRingPhysAddr);
-                else
-                        writel((u32) (np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)), base + NvRegTxRingPhysAddr);
+                setup_hw_rings(dev, NV_SETUP_TX_RING);
                 netif_wake_queue(dev);
         }
 
@@ -1342,6 +1449,8 @@ static void nv_rx_process(struct net_device *dev)
 {
         struct fe_priv *np = netdev_priv(dev);
         u32 Flags;
+        u32 vlanflags = 0;
+
 
         for (;;) {
                 struct sk_buff *skb;
@@ -1357,6 +1466,7 @@ static void nv_rx_process(struct net_device *dev)
                 } else {
                         Flags = le32_to_cpu(np->rx_ring.ex[i].FlagLen);
                         len = nv_descr_getlength_ex(&np->rx_ring.ex[i], np->desc_ver);
+                        vlanflags = le32_to_cpu(np->rx_ring.ex[i].PacketBufferLow);
                 }
 
                 dprintk(KERN_DEBUG "%s: nv_rx_process: looking at packet %d, Flags 0x%x.\n",
@@ -1474,7 +1584,11 @@ static void nv_rx_process(struct net_device *dev)
                 skb->protocol = eth_type_trans(skb, dev);
                 dprintk(KERN_DEBUG "%s: nv_rx_process: packet %d with %d bytes, proto %d accepted.\n",
                                         dev->name, np->cur_rx, len, skb->protocol);
-                netif_rx(skb);
+                if (np->vlangrp && (vlanflags & NV_RX3_VLAN_TAG_PRESENT)) {
+                        vlan_hwaccel_rx(skb, np->vlangrp, vlanflags & NV_RX3_VLAN_TAG_MASK);
+                } else {
+                        netif_rx(skb);
+                }
                 dev->last_rx = jiffies;
                 np->stats.rx_packets++;
                 np->stats.rx_bytes += len;
@@ -1523,7 +1637,15 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
                  * guessed, there is probably a simpler approach.
                  * Changing the MTU is a rare event, it shouldn't matter.
                  */
-                disable_irq(dev->irq);
+                if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+                    ((np->msi_flags & NV_MSI_X_ENABLED) && 
+                     ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                        disable_irq(dev->irq);
+                } else {
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
+                }
                 spin_lock_bh(&dev->xmit_lock);
                 spin_lock(&np->lock);
                 /* stop engines */
@@ -1544,11 +1666,7 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
                 }
                 /* reinit nic view of the rx queue */
                 writel(np->rx_buf_sz, base + NvRegOffloadConfig);
-                writel((u32) np->ring_addr, base + NvRegRxRingPhysAddr);
-                if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
-                        writel((u32) (np->ring_addr + RX_RING*sizeof(struct ring_desc)), base + NvRegTxRingPhysAddr);
-                else
-                        writel((u32) (np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)), base + NvRegTxRingPhysAddr);
+                setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING);
                 writel( ((RX_RING-1) << NVREG_RINGSZ_RXSHIFT) + ((TX_RING-1) << NVREG_RINGSZ_TXSHIFT),
                         base + NvRegRingSizes);
                 pci_push(base);
@@ -1560,7 +1678,15 @@ static int nv_change_mtu(struct net_device *dev, int new_mtu)
                 nv_start_tx(dev);
                 spin_unlock(&np->lock);
                 spin_unlock_bh(&dev->xmit_lock);
-                enable_irq(dev->irq);
+                if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+                    ((np->msi_flags & NV_MSI_X_ENABLED) && 
+                     ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                        enable_irq(dev->irq);
+                } else {
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
+                }
         }
         return 0;
 }
@@ -1866,8 +1992,13 @@ static irqreturn_t nv_nic_irq(int foo, void *data, struct pt_regs *regs)
         dprintk(KERN_DEBUG "%s: nv_nic_irq\n", dev->name);
 
         for (i=0; ; i++) {
-                events = readl(base + NvRegIrqStatus) & NVREG_IRQSTAT_MASK;
-                writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus);
+                if (!(np->msi_flags & NV_MSI_X_ENABLED)) {
+                        events = readl(base + NvRegIrqStatus) & NVREG_IRQSTAT_MASK;
+                        writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus);
+                } else {
+                        events = readl(base + NvRegMSIXIrqStatus) & NVREG_IRQSTAT_MASK;
+                        writel(NVREG_IRQSTAT_MASK, base + NvRegMSIXIrqStatus);
+                }
                 pci_push(base);
                 dprintk(KERN_DEBUG "%s: irq: %08x\n", dev->name, events);
                 if (!(events & np->irqmask))
@@ -1907,11 +2038,16 @@ static irqreturn_t nv_nic_irq(int foo, void *data, struct pt_regs *regs)
                 if (i > max_interrupt_work) {
                         spin_lock(&np->lock);
                         /* disable interrupts on the nic */
-                        writel(0, base + NvRegIrqMask);
+                        if (!(np->msi_flags & NV_MSI_X_ENABLED))
+                                writel(0, base + NvRegIrqMask);
+                        else
+                                writel(np->irqmask, base + NvRegIrqMask);
                         pci_push(base);
 
-                        if (!np->in_shutdown)
+                        if (!np->in_shutdown) {
+                                np->nic_poll_irq = np->irqmask;
                                 mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
+                        }
                         printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq.\n", dev->name, i);
                         spin_unlock(&np->lock);
                         break;
@@ -1923,22 +2059,212 @@ static irqreturn_t nv_nic_irq(int foo, void *data, struct pt_regs *regs)
         return IRQ_RETVAL(i);
 }
 
+static irqreturn_t nv_nic_irq_tx(int foo, void *data, struct pt_regs *regs)
+{
+        struct net_device *dev = (struct net_device *) data;
+        struct fe_priv *np = netdev_priv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+        u32 events;
+        int i;
+
+        dprintk(KERN_DEBUG "%s: nv_nic_irq_tx\n", dev->name);
+
+        for (i=0; ; i++) {
+                events = readl(base + NvRegMSIXIrqStatus) & NVREG_IRQ_TX_ALL;
+                writel(NVREG_IRQ_TX_ALL, base + NvRegMSIXIrqStatus);
+                pci_push(base);
+                dprintk(KERN_DEBUG "%s: tx irq: %08x\n", dev->name, events);
+                if (!(events & np->irqmask))
+                        break;
+
+                spin_lock(&np->lock);
+                nv_tx_done(dev);
+                spin_unlock(&np->lock);
+                
+                if (events & (NVREG_IRQ_TX_ERR)) {
+                        dprintk(KERN_DEBUG "%s: received irq with events 0x%x. Probably TX fail.\n",
+                                                dev->name, events);
+                }
+                if (i > max_interrupt_work) {
+                        spin_lock(&np->lock);
+                        /* disable interrupts on the nic */
+                        writel(NVREG_IRQ_TX_ALL, base + NvRegIrqMask);
+                        pci_push(base);
+
+                        if (!np->in_shutdown) {
+                                np->nic_poll_irq |= NVREG_IRQ_TX_ALL;
+                                mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
+                        }
+                        printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_tx.\n", dev->name, i);
+                        spin_unlock(&np->lock);
+                        break;
+                }
+
+        }
+        dprintk(KERN_DEBUG "%s: nv_nic_irq_tx completed\n", dev->name);
+
+        return IRQ_RETVAL(i);
+}
+
+static irqreturn_t nv_nic_irq_rx(int foo, void *data, struct pt_regs *regs)
+{
+        struct net_device *dev = (struct net_device *) data;
+        struct fe_priv *np = netdev_priv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+        u32 events;
+        int i;
+
+        dprintk(KERN_DEBUG "%s: nv_nic_irq_rx\n", dev->name);
+
+        for (i=0; ; i++) {
+                events = readl(base + NvRegMSIXIrqStatus) & NVREG_IRQ_RX_ALL;
+                writel(NVREG_IRQ_RX_ALL, base + NvRegMSIXIrqStatus);
+                pci_push(base);
+                dprintk(KERN_DEBUG "%s: rx irq: %08x\n", dev->name, events);
+                if (!(events & np->irqmask))
+                        break;
+                
+                nv_rx_process(dev);
+                if (nv_alloc_rx(dev)) {
+                        spin_lock(&np->lock);
+                        if (!np->in_shutdown)
+                                mod_timer(&np->oom_kick, jiffies + OOM_REFILL);
+                        spin_unlock(&np->lock);
+                }
+                
+                if (i > max_interrupt_work) {
+                        spin_lock(&np->lock);
+                        /* disable interrupts on the nic */
+                        writel(NVREG_IRQ_RX_ALL, base + NvRegIrqMask);
+                        pci_push(base);
+
+                        if (!np->in_shutdown) {
+                                np->nic_poll_irq |= NVREG_IRQ_RX_ALL;
+                                mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
+                        }
+                        printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_rx.\n", dev->name, i);
+                        spin_unlock(&np->lock);
+                        break;
+                }
+
+        }
+        dprintk(KERN_DEBUG "%s: nv_nic_irq_rx completed\n", dev->name);
+
+        return IRQ_RETVAL(i);
+}
+
+static irqreturn_t nv_nic_irq_other(int foo, void *data, struct pt_regs *regs)
+{
+        struct net_device *dev = (struct net_device *) data;
+        struct fe_priv *np = netdev_priv(dev);
+        u8 __iomem *base = get_hwbase(dev);
+        u32 events;
+        int i;
+
+        dprintk(KERN_DEBUG "%s: nv_nic_irq_other\n", dev->name);
+
+        for (i=0; ; i++) {
+                events = readl(base + NvRegMSIXIrqStatus) & NVREG_IRQ_OTHER;
+                writel(NVREG_IRQ_OTHER, base + NvRegMSIXIrqStatus);
+                pci_push(base);
+                dprintk(KERN_DEBUG "%s: irq: %08x\n", dev->name, events);
+                if (!(events & np->irqmask))
+                        break;
+                
+                if (events & NVREG_IRQ_LINK) {
+                        spin_lock(&np->lock);
+                        nv_link_irq(dev);
+                        spin_unlock(&np->lock);
+                }
+                if (np->need_linktimer && time_after(jiffies, np->link_timeout)) {
+                        spin_lock(&np->lock);
+                        nv_linkchange(dev);
+                        spin_unlock(&np->lock);
+                        np->link_timeout = jiffies + LINK_TIMEOUT;
+                }
+                if (events & (NVREG_IRQ_UNKNOWN)) {
+                        printk(KERN_DEBUG "%s: received irq with unknown events 0x%x. Please report\n",
+                                                dev->name, events);
+                }
+                if (i > max_interrupt_work) {
+                        spin_lock(&np->lock);
+                        /* disable interrupts on the nic */
+                        writel(NVREG_IRQ_OTHER, base + NvRegIrqMask);
+                        pci_push(base);
+
+                        if (!np->in_shutdown) {
+                                np->nic_poll_irq |= NVREG_IRQ_OTHER;
+                                mod_timer(&np->nic_poll, jiffies + POLL_WAIT);
+                        }
+                        printk(KERN_DEBUG "%s: too many iterations (%d) in nv_nic_irq_other.\n", dev->name, i);
+                        spin_unlock(&np->lock);
+                        break;
+                }
+
+        }
+        dprintk(KERN_DEBUG "%s: nv_nic_irq_other completed\n", dev->name);
+
+        return IRQ_RETVAL(i);
+}
+
 static void nv_do_nic_poll(unsigned long data)
 {
         struct net_device *dev = (struct net_device *) data;
         struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
+        u32 mask = 0;
 
-        disable_irq(dev->irq);
-        /* FIXME: Do we need synchronize_irq(dev->irq) here? */
         /*
+         * First disable irq(s) and then
          * reenable interrupts on the nic, we have to do this before calling
          * nv_nic_irq because that may decide to do otherwise
          */
-        writel(np->irqmask, base + NvRegIrqMask);
+
+        if (!(np->msi_flags & NV_MSI_X_ENABLED) ||
+            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                disable_irq(dev->irq);
+                mask = np->irqmask;
+        } else {
+                if (np->nic_poll_irq & NVREG_IRQ_RX_ALL) {
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+                        mask |= NVREG_IRQ_RX_ALL;
+                }
+                if (np->nic_poll_irq & NVREG_IRQ_TX_ALL) {
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
+                        mask |= NVREG_IRQ_TX_ALL;
+                }
+                if (np->nic_poll_irq & NVREG_IRQ_OTHER) {
+                        disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
+                        mask |= NVREG_IRQ_OTHER;
+                }
+        }
+        np->nic_poll_irq = 0;
+
+        /* FIXME: Do we need synchronize_irq(dev->irq) here? */
+        
+        writel(mask, base + NvRegIrqMask);
         pci_push(base);
-        nv_nic_irq((int) 0, (void *) data, (struct pt_regs *) NULL);
-        enable_irq(dev->irq);
+
+        if (!(np->msi_flags & NV_MSI_X_ENABLED) || 
+            ((np->msi_flags & NV_MSI_X_ENABLED) && 
+             ((np->msi_flags & NV_MSI_X_VECTORS_MASK) == 0x1))) {
+                nv_nic_irq((int) 0, (void *) data, (struct pt_regs *) NULL);
+                enable_irq(dev->irq);
+        } else {
+                if (np->nic_poll_irq & NVREG_IRQ_RX_ALL) {
+                        nv_nic_irq_rx((int) 0, (void *) data, (struct pt_regs *) NULL);
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
+                }
+                if (np->nic_poll_irq & NVREG_IRQ_TX_ALL) {
+                        nv_nic_irq_tx((int) 0, (void *) data, (struct pt_regs *) NULL);
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
+                }
+                if (np->nic_poll_irq & NVREG_IRQ_OTHER) {
+                        nv_nic_irq_other((int) 0, (void *) data, (struct pt_regs *) NULL);
+                        enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector);
+                }
+        }
 }
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -2217,11 +2543,66 @@ static struct ethtool_ops ops = {
         .get_perm_addr = ethtool_op_get_perm_addr,
 };
 
+static void nv_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
+{
+        struct fe_priv *np = get_nvpriv(dev);
+
+        spin_lock_irq(&np->lock);
+
+        /* save vlan group */
+        np->vlangrp = grp;
+
+        if (grp) {
+                /* enable vlan on MAC */
+                np->txrxctl_bits |= NVREG_TXRXCTL_VLANSTRIP | NVREG_TXRXCTL_VLANINS;
+        } else {
+                /* disable vlan on MAC */
+                np->txrxctl_bits &= ~NVREG_TXRXCTL_VLANSTRIP;
+                np->txrxctl_bits &= ~NVREG_TXRXCTL_VLANINS;
+        }
+
+        writel(np->txrxctl_bits, get_hwbase(dev) + NvRegTxRxControl);
+
+        spin_unlock_irq(&np->lock);
+};
+
+static void nv_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
+{
+        /* nothing to do */
+};
+
+static void set_msix_vector_map(struct net_device *dev, u32 vector, u32 irqmask)
+{
+        u8 __iomem *base = get_hwbase(dev);
+        int i;
+        u32 msixmap = 0;
+
+        /* Each interrupt bit can be mapped to a MSIX vector (4 bits).
+         * MSIXMap0 represents the first 8 interrupts and MSIXMap1 represents
+         * the remaining 8 interrupts.
+         */
+        for (i = 0; i < 8; i++) {
+                if ((irqmask >> i) & 0x1) {
+                        msixmap |= vector << (i << 2);
+                }
+        }
+        writel(readl(base + NvRegMSIXMap0) | msixmap, base + NvRegMSIXMap0);
+
+        msixmap = 0;
+        for (i = 0; i < 8; i++) {
+                if ((irqmask >> (i + 8)) & 0x1) {
+                        msixmap |= vector << (i << 2);
+                }
+        }
+        writel(readl(base + NvRegMSIXMap1) | msixmap, base + NvRegMSIXMap1);
+}
+
 static int nv_open(struct net_device *dev)
 {
         struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base = get_hwbase(dev);
-        int ret, oom, i;
+        int ret = 1;
+        int oom, i;
 
         dprintk(KERN_DEBUG "nv_open: begin\n");
 
@@ -2253,11 +2634,7 @@ static int nv_open(struct net_device *dev)
         nv_copy_mac_to_hw(dev);
 
         /* 4) give hw rings */
-        writel((u32) np->ring_addr, base + NvRegRxRingPhysAddr);
-        if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2)
-                writel((u32) (np->ring_addr + RX_RING*sizeof(struct ring_desc)), base + NvRegTxRingPhysAddr);
-        else
-                writel((u32) (np->ring_addr + RX_RING*sizeof(struct ring_desc_ex)), base + NvRegTxRingPhysAddr);
+        setup_hw_rings(dev, NV_SETUP_RX_RING | NV_SETUP_TX_RING);
         writel( ((RX_RING-1) << NVREG_RINGSZ_RXSHIFT) + ((TX_RING-1) << NVREG_RINGSZ_TXSHIFT),
                 base + NvRegRingSizes);
 
@@ -2265,6 +2642,7 @@ static int nv_open(struct net_device *dev)
         writel(np->linkspeed, base + NvRegLinkSpeed);
         writel(NVREG_UNKSETUP3_VAL1, base + NvRegUnknownSetupReg3);
         writel(np->txrxctl_bits, base + NvRegTxRxControl);
+        writel(np->vlanctl_bits, base + NvRegVlanControl);
         pci_push(base);
         writel(NVREG_TXRXCTL_BIT1|np->txrxctl_bits, base + NvRegTxRxControl);
         reg_delay(dev, NvRegUnknownSetupReg5, NVREG_UNKSETUP5_BIT31, NVREG_UNKSETUP5_BIT31,
@@ -2315,9 +2693,77 @@ static int nv_open(struct net_device *dev)
         writel(NVREG_IRQSTAT_MASK, base + NvRegIrqStatus);
         pci_push(base);
 
-        ret = request_irq(dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev);
-        if (ret)
-                goto out_drain;
+        if (np->msi_flags & NV_MSI_X_CAPABLE) {
+                for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) {
+                        np->msi_x_entry[i].entry = i;
+                }
+                if ((ret = pci_enable_msix(np->pci_dev, np->msi_x_entry, (np->msi_flags & NV_MSI_X_VECTORS_MASK))) == 0) {
+                        np->msi_flags |= NV_MSI_X_ENABLED;
+                        if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT) {
+                                /* Request irq for rx handling */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector, &nv_nic_irq_rx, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed for rx %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_drain;
+                                }
+                                /* Request irq for tx handling */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector, &nv_nic_irq_tx, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed for tx %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_drain;
+                                }
+                                /* Request irq for link and timer handling */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_OTHER].vector, &nv_nic_irq_other, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed for link %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_drain;
+                                }
+
+                                /* map interrupts to their respective vector */
+                                writel(0, base + NvRegMSIXMap0);
+                                writel(0, base + NvRegMSIXMap1);
+                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_RX, NVREG_IRQ_RX_ALL);
+                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_TX, NVREG_IRQ_TX_ALL);
+                                set_msix_vector_map(dev, NV_MSI_X_VECTOR_OTHER, NVREG_IRQ_OTHER);
+                        } else {
+                                /* Request irq for all interrupts */
+                                if (request_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) {
+                                        printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
+                                        pci_disable_msix(np->pci_dev);
+                                        np->msi_flags &= ~NV_MSI_X_ENABLED;
+                                        goto out_drain;
+                                }
+
+                                /* map interrupts to vector 0 */
+                                writel(0, base + NvRegMSIXMap0);
+                                writel(0, base + NvRegMSIXMap1);
+                        }
+                }
+        }
+        if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) {
+                if ((ret = pci_enable_msi(np->pci_dev)) == 0) {
+                        np->msi_flags |= NV_MSI_ENABLED;
+                        if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0) {
+                                printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
+                                pci_disable_msi(np->pci_dev);
+                                np->msi_flags &= ~NV_MSI_ENABLED;
+                                goto out_drain;
+                        }
+
+                        /* map interrupts to vector 0 */
+                        writel(0, base + NvRegMSIMap0);
+                        writel(0, base + NvRegMSIMap1);
+                        /* enable msi vector 0 */
+                        writel(NVREG_MSI_VECTOR_0_ENABLED, base + NvRegMSIIrqMask);
+                }
+        }
+        if (ret != 0) {
+                if (request_irq(np->pci_dev->irq, &nv_nic_irq, SA_SHIRQ, dev->name, dev) != 0)
+                        goto out_drain;
+        }
 
         /* ask for interrupts */
         writel(np->irqmask, base + NvRegIrqMask);
@@ -2364,6 +2810,7 @@ static int nv_close(struct net_device *dev)
 {
         struct fe_priv *np = netdev_priv(dev);
         u8 __iomem *base;
+        int i;
 
         spin_lock_irq(&np->lock);
         np->in_shutdown = 1;
@@ -2381,13 +2828,31 @@ static int nv_close(struct net_device *dev)
 
         /* disable interrupts on the nic or we will lock up */
         base = get_hwbase(dev);
-        writel(0, base + NvRegIrqMask);
+        if (np->msi_flags & NV_MSI_X_ENABLED) {
+                writel(np->irqmask, base + NvRegIrqMask);
+        } else {
+                if (np->msi_flags & NV_MSI_ENABLED)
+                        writel(0, base + NvRegMSIIrqMask);
+                writel(0, base + NvRegIrqMask);
+        }
         pci_push(base);
         dprintk(KERN_INFO "%s: Irqmask is zero again\n", dev->name);
 
         spin_unlock_irq(&np->lock);
 
-        free_irq(dev->irq, dev);
+        if (np->msi_flags & NV_MSI_X_ENABLED) {
+                for (i = 0; i < (np->msi_flags & NV_MSI_X_VECTORS_MASK); i++) {
+                        free_irq(np->msi_x_entry[i].vector, dev);
+                }
+                pci_disable_msix(np->pci_dev);
+                np->msi_flags &= ~NV_MSI_X_ENABLED;
+        } else {
+                free_irq(np->pci_dev->irq, dev);
+                if (np->msi_flags & NV_MSI_ENABLED) {
+                        pci_disable_msi(np->pci_dev);
+                        np->msi_flags &= ~NV_MSI_ENABLED;
+                }
+        }
 
         drain_ring(dev);
 
@@ -2471,7 +2936,14 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                         printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n",
                                         pci_name(pci_dev));
                 } else {
-                        dev->features |= NETIF_F_HIGHDMA;
+                        if (pci_set_consistent_dma_mask(pci_dev, 0x0000007fffffffffULL)) {
+                                printk(KERN_INFO "forcedeth: 64-bit DMA (consistent) failed for device %s.\n",
+                                        pci_name(pci_dev));
+                                goto out_relreg;
+                        } else {
+                                dev->features |= NETIF_F_HIGHDMA;
+                                printk(KERN_INFO "forcedeth: using HIGHDMA\n");
+                        }
                 }
                 np->txrxctl_bits = NVREG_TXRXCTL_DESC_3;
         } else if (id->driver_data & DEV_HAS_LARGEDESC) {
@@ -2496,6 +2968,22 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
 #endif
         }
 
+        np->vlanctl_bits = 0;
+        if (id->driver_data & DEV_HAS_VLAN) {
+                np->vlanctl_bits = NVREG_VLANCONTROL_ENABLE;
+                dev->features |= NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX;
+                dev->vlan_rx_register = nv_vlan_rx_register;
+                dev->vlan_rx_kill_vid = nv_vlan_rx_kill_vid;
+        }
+
+        np->msi_flags = 0;
+        if ((id->driver_data & DEV_HAS_MSI) && !disable_msi) {
+                np->msi_flags |= NV_MSI_CAPABLE;
+        }
+        if ((id->driver_data & DEV_HAS_MSI_X) && !disable_msix) {
+                np->msi_flags |= NV_MSI_X_CAPABLE;
+        }
+
         err = -ENOMEM;
         np->base = ioremap(addr, NV_PCI_REGSZ);
         if (!np->base)
@@ -2578,10 +3066,15 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
         } else {
                 np->tx_flags = NV_TX2_VALID;
         }
-        if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT)
+        if (optimization_mode == NV_OPTIMIZATION_MODE_THROUGHPUT) {
                 np->irqmask = NVREG_IRQMASK_THROUGHPUT;
-        else
+                if (np->msi_flags & NV_MSI_X_CAPABLE) /* set number of vectors */
+                        np->msi_flags |= 0x0003;
+        } else {
                 np->irqmask = NVREG_IRQMASK_CPU;
+                if (np->msi_flags & NV_MSI_X_CAPABLE) /* set number of vectors */
+                        np->msi_flags |= 0x0001;
+        }
 
         if (id->driver_data & DEV_NEED_TIMERIRQ)
                 np->irqmask |= NVREG_IRQ_TIMER;
@@ -2737,11 +3230,11 @@ static struct pci_device_id pci_tbl[] = {
         },
         {       /* MCP55 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_14),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X,
         },
         {       /* MCP55 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_15),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_VLAN|DEV_HAS_MSI|DEV_HAS_MSI_X,
         },
         {0,},
 };
@@ -2771,6 +3264,10 @@ module_param(optimization_mode, int, 0);
 MODULE_PARM_DESC(optimization_mode, "In throughput mode (0), every tx & rx packet will generate an interrupt. In CPU mode (1), interrupts are controlled by a timer.");
 module_param(poll_interval, int, 0);
 MODULE_PARM_DESC(poll_interval, "Interval determines how frequent timer interrupt is generated by [(time_in_micro_secs * 100) / (2^10)]. Min is 0 and Max is 65535.");
+module_param(disable_msi, int, 0);
+MODULE_PARM_DESC(disable_msi, "Disable MSI interrupts by setting to 1.");
+module_param(disable_msix, int, 0);
+MODULE_PARM_DESC(disable_msix, "Disable MSIX interrupts by setting to 1.");
 
 MODULE_AUTHOR("Manfred Spraul <manfred@colorfullife.com>");
 MODULE_DESCRIPTION("Reverse Engineered nForce ethernet driver");
diff --git a/drivers/net/ifb.c b/drivers/net/ifb.c
index 1b699259b4ec..31fb2d75dc44 100644
--- a/drivers/net/ifb.c
+++ b/drivers/net/ifb.c
@@ -57,7 +57,7 @@ struct ifb_private {
         struct sk_buff_head     tq;
 };
 
-static int numifbs = 1;
+static int numifbs = 2;
 
 static void ri_tasklet(unsigned long dev);
 static int ifb_xmit(struct sk_buff *skb, struct net_device *dev);
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index fa176ffb4ad5..8936058a3cce 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -108,6 +108,7 @@ static void irda_usb_close(struct irda_usb_cb *self);
 static void speed_bulk_callback(struct urb *urb, struct pt_regs *regs);
 static void write_bulk_callback(struct urb *urb, struct pt_regs *regs);
 static void irda_usb_receive(struct urb *urb, struct pt_regs *regs);
+static void irda_usb_rx_defer_expired(unsigned long data);
 static int irda_usb_net_open(struct net_device *dev);
 static int irda_usb_net_close(struct net_device *dev);
 static int irda_usb_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
@@ -677,6 +678,12 @@ static void irda_usb_net_timeout(struct net_device *netdev)
  * on the interrupt pipe and hang the Rx URB only when an interrupt is
  * received.
  * Jean II
+ *
+ * Note : don't read the above as what we are currently doing, but as
+ * something we could do with KC dongle. Also don't forget that the
+ * interrupt pipe is not part of the original standard, so this would
+ * need to be optional...
+ * Jean II
  */
 
 /*------------------------------------------------------------------*/
@@ -704,10 +711,8 @@ static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struc
         /* Reinitialize URB */
         usb_fill_bulk_urb(urb, self->usbdev, 
                       usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep), 
-                      skb->data, skb->truesize,
+                      skb->data, IRDA_SKB_MAX_MTU,
                       irda_usb_receive, skb);
-        /* Note : unlink *must* be synchronous because of the code in 
-         * irda_usb_net_close() -> free the skb - Jean II */
         urb->status = 0;
 
         /* Can be called from irda_usb_receive (irq handler) -> GFP_ATOMIC */
@@ -734,6 +739,7 @@ static void irda_usb_receive(struct urb *urb, struct pt_regs *regs)
         struct irda_skb_cb *cb;
         struct sk_buff *newskb;
         struct sk_buff *dataskb;
+        struct urb *next_urb;
         int             docopy;
 
         IRDA_DEBUG(2, "%s(), len=%d\n", __FUNCTION__, urb->actual_length);
@@ -755,20 +761,37 @@ static void irda_usb_receive(struct urb *urb, struct pt_regs *regs)
         if (urb->status != 0) {
                 switch (urb->status) {
                 case -EILSEQ:
-                        self->stats.rx_errors++;
                         self->stats.rx_crc_errors++;    
-                        break;
+                        /* Also precursor to a hot-unplug on UHCI. */
+                        /* Fallthrough... */
                 case -ECONNRESET:               /* -104 */
-                        IRDA_DEBUG(0, "%s(), Connection Reset (-104), transfer_flags 0x%04X \n", __FUNCTION__, urb->transfer_flags);
+                        /* Random error, if I remember correctly */
                         /* uhci_cleanup_unlink() is going to kill the Rx
                          * URB just after we return. No problem, at this
                          * point the URB will be idle ;-) - Jean II */
-                        break;
+                case -ESHUTDOWN:                /* -108 */
+                        /* That's usually a hot-unplug. Submit will fail... */
+                case -ETIMEDOUT:                /* -110 */
+                        /* Usually precursor to a hot-unplug on OHCI. */
                 default:
-                        IRDA_DEBUG(0, "%s(), RX status %d,transfer_flags 0x%04X \n", __FUNCTION__, urb->status, urb->transfer_flags);
+                        self->stats.rx_errors++;
+                        IRDA_DEBUG(0, "%s(), RX status %d, transfer_flags 0x%04X \n", __FUNCTION__, urb->status, urb->transfer_flags);
                         break;
                 }
-                goto done;
+                /* If we received an error, we don't want to resubmit the
+                 * Rx URB straight away but to give the USB layer a little
+                 * bit of breathing room.
+                 * We are in the USB thread context, therefore there is a
+                 * danger of recursion (new URB we submit fails, we come
+                 * back here).
+                 * With recent USB stack (2.6.15+), I'm seeing that on
+                 * hot unplug of the dongle...
+                 * Lowest effective timer is 10ms...
+                 * Jean II */
+                self->rx_defer_timer.function = &irda_usb_rx_defer_expired;
+                self->rx_defer_timer.data = (unsigned long) urb;
+                mod_timer(&self->rx_defer_timer, jiffies + (10 * HZ / 1000));
+                return;
         }
         
         /* Check for empty frames */
@@ -845,13 +868,45 @@ done:
          * idle slot....
          * Jean II */
         /* Note : with this scheme, we could submit the idle URB before
-         * processing the Rx URB. Another time... Jean II */
+         * processing the Rx URB. I don't think it would buy us anything as
+         * we are running in the USB thread context. Jean II */
+        next_urb = self->idle_rx_urb;
 
-        /* Submit the idle URB to replace the URB we've just received */
-        irda_usb_submit(self, skb, self->idle_rx_urb);
         /* Recycle Rx URB : Now, the idle URB is the present one */
         urb->context = NULL;
         self->idle_rx_urb = urb;
+
+        /* Submit the idle URB to replace the URB we've just received.
+         * Do it last to avoid race conditions... Jean II */
+        irda_usb_submit(self, skb, next_urb);
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * In case of errors, we want the USB layer to have time to recover.
+ * Now, it is time to resubmit ouur Rx URB...
+ */
+static void irda_usb_rx_defer_expired(unsigned long data)
+{
+        struct urb *urb = (struct urb *) data;
+        struct sk_buff *skb = (struct sk_buff *) urb->context;
+        struct irda_usb_cb *self; 
+        struct irda_skb_cb *cb;
+        struct urb *next_urb;
+
+        IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
+
+        /* Find ourselves */
+        cb = (struct irda_skb_cb *) skb->cb;
+        IRDA_ASSERT(cb != NULL, return;);
+        self = (struct irda_usb_cb *) cb->context;
+        IRDA_ASSERT(self != NULL, return;);
+
+        /* Same stuff as when Rx is done, see above... */
+        next_urb = self->idle_rx_urb;
+        urb->context = NULL;
+        self->idle_rx_urb = urb;
+        irda_usb_submit(self, skb, next_urb);
 }
 
 /*------------------------------------------------------------------*/
@@ -990,6 +1045,9 @@ static int irda_usb_net_close(struct net_device *netdev)
         /* Stop network Tx queue */
         netif_stop_queue(netdev);
 
+        /* Kill defered Rx URB */
+        del_timer(&self->rx_defer_timer);
+
         /* Deallocate all the Rx path buffers (URBs and skb) */
         for (i = 0; i < IU_MAX_RX_URBS; i++) {
                 struct urb *urb = self->rx_urb[i];
@@ -1365,6 +1423,7 @@ static int irda_usb_probe(struct usb_interface *intf,
         self = net->priv;
         self->netdev = net;
         spin_lock_init(&self->lock);
+        init_timer(&self->rx_defer_timer);
 
         /* Create all of the needed urbs */
         for (i = 0; i < IU_MAX_RX_URBS; i++) {
@@ -1498,6 +1557,9 @@ static void irda_usb_disconnect(struct usb_interface *intf)
          * This will stop/desactivate the Tx path. - Jean II */
         self->present = 0;
 
+        /* Kill defered Rx URB */
+        del_timer(&self->rx_defer_timer);
+
         /* We need to have irq enabled to unlink the URBs. That's OK,
          * at this point the Tx path is gone - Jean II */
         spin_unlock_irqrestore(&self->lock, flags);
@@ -1507,11 +1569,11 @@ static void irda_usb_disconnect(struct usb_interface *intf)
                 /* Accept no more transmissions */
                 /*netif_device_detach(self->netdev);*/
                 netif_stop_queue(self->netdev);
-                /* Stop all the receive URBs */
+                /* Stop all the receive URBs. Must be synchronous. */
                 for (i = 0; i < IU_MAX_RX_URBS; i++)
                         usb_kill_urb(self->rx_urb[i]);
                 /* Cancel Tx and speed URB.
-                 * Toggle flags to make sure it's synchronous. */
+                 * Make sure it's synchronous to avoid races. */
                 usb_kill_urb(self->tx_urb);
                 usb_kill_urb(self->speed_urb);
         }
diff --git a/drivers/net/irda/irda-usb.h b/drivers/net/irda/irda-usb.h
index bd8f66542322..4026af42dd47 100644
--- a/drivers/net/irda/irda-usb.h
+++ b/drivers/net/irda/irda-usb.h
@@ -136,8 +136,6 @@ struct irda_usb_cb {
         __u16 bulk_out_mtu;             /* Max Tx packet size in bytes */
         __u8  bulk_int_ep;              /* Interrupt Endpoint assignments */
 
-        wait_queue_head_t wait_q;       /* for timeouts */
-
         struct urb *rx_urb[IU_MAX_RX_URBS];     /* URBs used to receive data frames */
         struct urb *idle_rx_urb;        /* Pointer to idle URB in Rx path */
         struct urb *tx_urb;             /* URB used to send data frames */
@@ -147,17 +145,18 @@ struct irda_usb_cb {
         struct net_device_stats stats;
         struct irlap_cb   *irlap;       /* The link layer we are binded to */
         struct qos_info qos;
-        hashbin_t *tx_list;             /* Queued transmit skb's */
         char *speed_buff;               /* Buffer for speed changes */
 
         struct timeval stamp;
         struct timeval now;
 
-        spinlock_t lock;                /* For serializing operations */
+        spinlock_t lock;                /* For serializing Tx operations */
 
         __u16 xbofs;                    /* Current xbofs setting */
         __s16 new_xbofs;                /* xbofs we need to set */
         __u32 speed;                    /* Current speed */
         __s32 new_speed;                /* speed we need to set */
+
+        struct timer_list rx_defer_timer;       /* Wait for Rx error to clear */
 };
 
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 6e1018448eea..8cc0d0bbdf50 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -287,6 +287,20 @@ enum RTL8169_register_content {
         TxInterFrameGapShift = 24,
         TxDMAShift = 8, /* DMA burst value (0-7) is shift this many bits */
 
+        /* Config1 register p.24 */
+        PMEnable        = (1 << 0),     /* Power Management Enable */
+
+        /* Config3 register p.25 */
+        MagicPacket     = (1 << 5),     /* Wake up when receives a Magic Packet */
+        LinkUp          = (1 << 4),     /* Wake up when the cable connection is re-established */
+
+        /* Config5 register p.27 */
+        BWF             = (1 << 6),     /* Accept Broadcast wakeup frame */
+        MWF             = (1 << 5),     /* Accept Multicast wakeup frame */
+        UWF             = (1 << 4),     /* Accept Unicast wakeup frame */
+        LanWake         = (1 << 1),     /* LanWake enable/disable */
+        PMEStatus       = (1 << 0),     /* PME status can be reset by PCI RST# */
+
         /* TBICSR p.28 */
         TBIReset        = 0x80000000,
         TBILoopback     = 0x40000000,
@@ -433,6 +447,7 @@ struct rtl8169_private {
         unsigned int (*phy_reset_pending)(void __iomem *);
         unsigned int (*link_ok)(void __iomem *);
         struct work_struct task;
+        unsigned wol_enabled : 1;
 };
 
 MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>");
@@ -607,6 +622,80 @@ static void rtl8169_link_option(int idx, u8 *autoneg, u16 *speed, u8 *duplex)
         *duplex = p->duplex;
 }
 
+static void rtl8169_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+{
+        struct rtl8169_private *tp = netdev_priv(dev);
+        void __iomem *ioaddr = tp->mmio_addr;
+        u8 options;
+
+        wol->wolopts = 0;
+
+#define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST)
+        wol->supported = WAKE_ANY;
+
+        spin_lock_irq(&tp->lock);
+
+        options = RTL_R8(Config1);
+        if (!(options & PMEnable))
+                goto out_unlock;
+
+        options = RTL_R8(Config3);
+        if (options & LinkUp)
+                wol->wolopts |= WAKE_PHY;
+        if (options & MagicPacket)
+                wol->wolopts |= WAKE_MAGIC;
+
+        options = RTL_R8(Config5);
+        if (options & UWF)
+                wol->wolopts |= WAKE_UCAST;
+        if (options & BWF)
+                wol->wolopts |= WAKE_BCAST;
+        if (options & MWF)
+                wol->wolopts |= WAKE_MCAST;
+
+out_unlock:
+        spin_unlock_irq(&tp->lock);
+}
+
+static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
+{
+        struct rtl8169_private *tp = netdev_priv(dev);
+        void __iomem *ioaddr = tp->mmio_addr;
+        int i;
+        static struct {
+                u32 opt;
+                u16 reg;
+                u8  mask;
+        } cfg[] = {
+                { WAKE_ANY,   Config1, PMEnable },
+                { WAKE_PHY,   Config3, LinkUp },
+                { WAKE_MAGIC, Config3, MagicPacket },
+                { WAKE_UCAST, Config5, UWF },
+                { WAKE_BCAST, Config5, BWF },
+                { WAKE_MCAST, Config5, MWF },
+                { WAKE_ANY,   Config5, LanWake }
+        };
+
+        spin_lock_irq(&tp->lock);
+
+        RTL_W8(Cfg9346, Cfg9346_Unlock);
+
+        for (i = 0; i < ARRAY_SIZE(cfg); i++) {
+                u8 options = RTL_R8(cfg[i].reg) & ~cfg[i].mask;
+                if (wol->wolopts & cfg[i].opt)
+                        options |= cfg[i].mask;
+                RTL_W8(cfg[i].reg, options);
+        }
+
+        RTL_W8(Cfg9346, Cfg9346_Lock);
+
+        tp->wol_enabled = (wol->wolopts) ? 1 : 0;
+
+        spin_unlock_irq(&tp->lock);
+
+        return 0;
+}
+
 static void rtl8169_get_drvinfo(struct net_device *dev,
                                 struct ethtool_drvinfo *info)
 {
@@ -1025,6 +1114,8 @@ static struct ethtool_ops rtl8169_ethtool_ops = {
         .get_tso                = ethtool_op_get_tso,
         .set_tso                = ethtool_op_set_tso,
         .get_regs               = rtl8169_get_regs,
+        .get_wol                = rtl8169_get_wol,
+        .set_wol                = rtl8169_set_wol,
         .get_strings            = rtl8169_get_strings,
         .get_stats_count        = rtl8169_get_stats_count,
         .get_ethtool_stats      = rtl8169_get_ethtool_stats,
@@ -1442,6 +1533,11 @@ rtl8169_init_board(struct pci_dev *pdev, struct net_device **dev_out,
         }
         tp->chipset = i;
 
+        RTL_W8(Cfg9346, Cfg9346_Unlock);
+        RTL_W8(Config1, RTL_R8(Config1) | PMEnable);
+        RTL_W8(Config5, RTL_R8(Config5) & PMEStatus);
+        RTL_W8(Cfg9346, Cfg9346_Lock);
+
         *ioaddr_out = ioaddr;
         *dev_out = dev;
 out:
@@ -1612,49 +1708,6 @@ rtl8169_remove_one(struct pci_dev *pdev)
         pci_set_drvdata(pdev, NULL);
 }
 
-#ifdef CONFIG_PM
-
-static int rtl8169_suspend(struct pci_dev *pdev, pm_message_t state)
-{
-        struct net_device *dev = pci_get_drvdata(pdev);
-        struct rtl8169_private *tp = netdev_priv(dev);
-        void __iomem *ioaddr = tp->mmio_addr;
-        unsigned long flags;
-
-        if (!netif_running(dev))
-                return 0;
-        
-        netif_device_detach(dev);
-        netif_stop_queue(dev);
-        spin_lock_irqsave(&tp->lock, flags);
-
-        /* Disable interrupts, stop Rx and Tx */
-        RTL_W16(IntrMask, 0);
-        RTL_W8(ChipCmd, 0);
-                
-        /* Update the error counts. */
-        tp->stats.rx_missed_errors += RTL_R32(RxMissed);
-        RTL_W32(RxMissed, 0);
-        spin_unlock_irqrestore(&tp->lock, flags);
-        
-        return 0;
-}
-
-static int rtl8169_resume(struct pci_dev *pdev)
-{
-        struct net_device *dev = pci_get_drvdata(pdev);
-
-        if (!netif_running(dev))
-            return 0;
-
-        netif_device_attach(dev);
-        rtl8169_hw_start(dev);
-
-        return 0;
-}
-                                                                                
-#endif /* CONFIG_PM */
-
 static void rtl8169_set_rxbufsize(struct rtl8169_private *tp,
                                   struct net_device *dev)
 {
@@ -2700,6 +2753,56 @@ static struct net_device_stats *rtl8169_get_stats(struct net_device *dev)
         return &tp->stats;
 }
 
+#ifdef CONFIG_PM
+
+static int rtl8169_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        struct net_device *dev = pci_get_drvdata(pdev);
+        struct rtl8169_private *tp = netdev_priv(dev);
+        void __iomem *ioaddr = tp->mmio_addr;
+
+        if (!netif_running(dev))
+                goto out;
+
+        netif_device_detach(dev);
+        netif_stop_queue(dev);
+
+        spin_lock_irq(&tp->lock);
+
+        rtl8169_asic_down(ioaddr);
+
+        tp->stats.rx_missed_errors += RTL_R32(RxMissed);
+        RTL_W32(RxMissed, 0);
+
+        spin_unlock_irq(&tp->lock);
+
+        pci_save_state(pdev);
+        pci_enable_wake(pdev, pci_choose_state(pdev, state), tp->wol_enabled);
+        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+out:
+        return 0;
+}
+
+static int rtl8169_resume(struct pci_dev *pdev)
+{
+        struct net_device *dev = pci_get_drvdata(pdev);
+
+        if (!netif_running(dev))
+                goto out;
+
+        netif_device_attach(dev);
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+        pci_enable_wake(pdev, PCI_D0, 0);
+
+        rtl8169_schedule_work(dev, rtl8169_reset_task);
+out:
+        return 0;
+}
+
+#endif /* CONFIG_PM */
+
 static struct pci_driver rtl8169_pci_driver = {
         .name           = MODULENAME,
         .id_table       = rtl8169_pci_tbl,
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index b420182eec4b..ed4bc91638d2 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -1791,6 +1791,8 @@ static int __devinit sis190_init_one(struct pci_dev *pdev,
                 goto out;
         }
 
+        pci_set_drvdata(pdev, dev);
+
         tp = netdev_priv(dev);
         ioaddr = tp->mmio_addr;
 
@@ -1827,8 +1829,6 @@ static int __devinit sis190_init_one(struct pci_dev *pdev,
         if (rc < 0)
                 goto err_remove_mii;
 
-        pci_set_drvdata(pdev, dev);
-
         net_probe(tp, KERN_INFO "%s: %s at %p (IRQ: %d), "
                "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
                pci_name(pdev), sis_chip_info[ent->driver_data].name,
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 3d95fa20cd88..7a952fe60be2 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -540,7 +540,7 @@ static int __devinit sis900_probe(struct pci_dev *pci_dev,
         printk("%2.2x.\n", net_dev->dev_addr[i]);
 
         /* Detect Wake on Lan support */
-        ret = inl(CFGPMC & PMESP);
+        ret = (inl(net_dev->base_addr + CFGPMC) & PMESP) >> 27;
         if (netif_msg_probe(sis_priv) && (ret & PME_D3C) == 0)
                 printk(KERN_INFO "%s: Wake on LAN only available from suspend to RAM.", net_dev->name);
 
@@ -2040,7 +2040,7 @@ static int sis900_set_wol(struct net_device *net_dev, struct ethtool_wolinfo *wo
 
         if (wol->wolopts == 0) {
                 pci_read_config_dword(sis_priv->pci_dev, CFGPMCSR, &cfgpmcsr);
-                cfgpmcsr |= ~PME_EN;
+                cfgpmcsr &= ~PME_EN;
                 pci_write_config_dword(sis_priv->pci_dev, CFGPMCSR, cfgpmcsr);
                 outl(pmctrl_bits, pmctrl_addr);
                 if (netif_msg_wol(sis_priv))
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index bf55a4cfb3d2..25e028b7ce48 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -879,13 +879,12 @@ static int __xm_phy_read(struct skge_hw *hw, int port, u16 reg, u16 *val)
         int i;
 
         xm_write16(hw, port, XM_PHY_ADDR, reg | hw->phy_addr);
-        xm_read16(hw, port, XM_PHY_DATA);
+        *val = xm_read16(hw, port, XM_PHY_DATA);
 
-        /* Need to wait for external PHY */
         for (i = 0; i < PHY_RETRIES; i++) {
-                udelay(1);
                 if (xm_read16(hw, port, XM_MMU_CMD) & XM_MMU_PHY_RDY)
                         goto ready;
+                udelay(1);
         }
 
         return -ETIMEDOUT;
@@ -918,7 +917,12 @@ static int xm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val)
 
  ready:
         xm_write16(hw, port, XM_PHY_DATA, val);
-        return 0;
+        for (i = 0; i < PHY_RETRIES; i++) {
+                if (!(xm_read16(hw, port, XM_MMU_CMD) & XM_MMU_PHY_BUSY))
+                        return 0;
+                udelay(1);
+        }
+        return -ETIMEDOUT;
 }
 
 static void genesis_init(struct skge_hw *hw)
@@ -1168,13 +1172,17 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
         u32 r;
         const u8 zero[6]  = { 0 };
 
-        /* Clear MIB counters */
-        xm_write16(hw, port, XM_STAT_CMD,
-                        XM_SC_CLR_RXC | XM_SC_CLR_TXC);
-        /* Clear two times according to Errata #3 */
-        xm_write16(hw, port, XM_STAT_CMD,
-                        XM_SC_CLR_RXC | XM_SC_CLR_TXC);
+        for (i = 0; i < 10; i++) {
+                skge_write16(hw, SK_REG(port, TX_MFF_CTRL1),
+                             MFF_SET_MAC_RST);
+                if (skge_read16(hw, SK_REG(port, TX_MFF_CTRL1)) & MFF_SET_MAC_RST)
+                        goto reset_ok;
+                udelay(1);
+        }
 
+        printk(KERN_WARNING PFX "%s: genesis reset failed\n", dev->name);
+
+ reset_ok:
         /* Unreset the XMAC. */
         skge_write16(hw, SK_REG(port, TX_MFF_CTRL1), MFF_CLR_MAC_RST);
 
@@ -1191,7 +1199,7 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
                 r |= GP_DIR_2|GP_IO_2;
 
         skge_write32(hw, B2_GP_IO, r);
-        skge_read32(hw, B2_GP_IO);
+
 
         /* Enable GMII interface */
         xm_write16(hw, port, XM_HW_CFG, XM_HW_GMII_MD);
@@ -1205,6 +1213,13 @@ static void genesis_mac_init(struct skge_hw *hw, int port)
         for (i = 1; i < 16; i++)
                 xm_outaddr(hw, port, XM_EXM(i), zero);
 
+        /* Clear MIB counters */
+        xm_write16(hw, port, XM_STAT_CMD,
+                        XM_SC_CLR_RXC | XM_SC_CLR_TXC);
+        /* Clear two times according to Errata #3 */
+        xm_write16(hw, port, XM_STAT_CMD,
+                        XM_SC_CLR_RXC | XM_SC_CLR_TXC);
+
         /* configure Rx High Water Mark (XM_RX_HI_WM) */
         xm_write16(hw, port, XM_RX_HI_WM, 1450);
 
@@ -1697,6 +1712,7 @@ static void yukon_mac_init(struct skge_hw *hw, int port)
         skge_write32(hw, SK_REG(port, GPHY_CTRL), reg | GPC_RST_SET);
         skge_write32(hw, SK_REG(port, GPHY_CTRL), reg | GPC_RST_CLR);
         skge_write32(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON | GMC_RST_CLR);
+
         if (skge->autoneg == AUTONEG_DISABLE) {
                 reg = GM_GPCR_AU_ALL_DIS;
                 gma_write16(hw, port, GM_GP_CTRL,
@@ -1704,16 +1720,23 @@ static void yukon_mac_init(struct skge_hw *hw, int port)
 
                 switch (skge->speed) {
                 case SPEED_1000:
+                        reg &= ~GM_GPCR_SPEED_100;
                         reg |= GM_GPCR_SPEED_1000;
-                        /* fallthru */
+                        break;
                 case SPEED_100:
+                        reg &= ~GM_GPCR_SPEED_1000;
                         reg |= GM_GPCR_SPEED_100;
+                        break;
+                case SPEED_10:
+                        reg &= ~(GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100);
+                        break;
                 }
 
                 if (skge->duplex == DUPLEX_FULL)
                         reg |= GM_GPCR_DUP_FULL;
         } else
                 reg = GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100 | GM_GPCR_DUP_FULL;
+
         switch (skge->flow_control) {
         case FLOW_MODE_NONE:
                 skge_write32(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
@@ -2162,8 +2185,10 @@ static int skge_up(struct net_device *dev)
         skge->tx_avail = skge->tx_ring.count - 1;
 
         /* Enable IRQ from port */
+        spin_lock_irq(&hw->hw_lock);
         hw->intr_mask |= portirqmask[port];
         skge_write32(hw, B0_IMSK, hw->intr_mask);
+        spin_unlock_irq(&hw->hw_lock);
 
         /* Initialize MAC */
         spin_lock_bh(&hw->phy_lock);
@@ -2221,8 +2246,10 @@ static int skge_down(struct net_device *dev)
         else
                 yukon_stop(skge);
 
+        spin_lock_irq(&hw->hw_lock);
         hw->intr_mask &= ~portirqmask[skge->port];
         skge_write32(hw, B0_IMSK, hw->intr_mask);
+        spin_unlock_irq(&hw->hw_lock);
 
         /* Stop transmitter */
         skge_write8(hw, Q_ADDR(txqaddr[port], Q_CSR), CSR_STOP);
@@ -2670,8 +2697,7 @@ static int skge_poll(struct net_device *dev, int *budget)
 
         /* restart receiver */
         wmb();
-        skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR),
-                    CSR_START | CSR_IRQ_CL_F);
+        skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_START);
 
         *budget -= work_done;
         dev->quota -= work_done;
@@ -2679,10 +2705,11 @@ static int skge_poll(struct net_device *dev, int *budget)
         if (work_done >=  to_do)
                 return 1; /* not done */
 
-        netif_rx_complete(dev);
-        hw->intr_mask |= portirqmask[skge->port];
-        skge_write32(hw, B0_IMSK, hw->intr_mask);
-        skge_read32(hw, B0_IMSK);
+        spin_lock_irq(&hw->hw_lock);
+        __netif_rx_complete(dev);
+        hw->intr_mask |= portirqmask[skge->port];
+        skge_write32(hw, B0_IMSK, hw->intr_mask);
+        spin_unlock_irq(&hw->hw_lock);
 
         return 0;
 }
@@ -2842,18 +2869,10 @@ static void skge_extirq(unsigned long data)
         }
         spin_unlock(&hw->phy_lock);
 
-        local_irq_disable();
+        spin_lock_irq(&hw->hw_lock);
         hw->intr_mask |= IS_EXT_REG;
         skge_write32(hw, B0_IMSK, hw->intr_mask);
-        local_irq_enable();
-}
-
-static inline void skge_wakeup(struct net_device *dev)
-{
-        struct skge_port *skge = netdev_priv(dev);
-
-        prefetch(skge->rx_ring.to_clean);
-        netif_rx_schedule(dev);
+        spin_unlock_irq(&hw->hw_lock);
 }
 
 static irqreturn_t skge_intr(int irq, void *dev_id, struct pt_regs *regs)
@@ -2864,15 +2883,17 @@ static irqreturn_t skge_intr(int irq, void *dev_id, struct pt_regs *regs)
         if (status == 0 || status == ~0) /* hotplug or shared irq */
                 return IRQ_NONE;
 
-        status &= hw->intr_mask;
+        spin_lock(&hw->hw_lock);
         if (status & IS_R1_F) {
+                skge_write8(hw, Q_ADDR(Q_R1, Q_CSR), CSR_IRQ_CL_F);
                 hw->intr_mask &= ~IS_R1_F;
-                skge_wakeup(hw->dev[0]);
+                netif_rx_schedule(hw->dev[0]);
         }
 
         if (status & IS_R2_F) {
+                skge_write8(hw, Q_ADDR(Q_R2, Q_CSR), CSR_IRQ_CL_F);
                 hw->intr_mask &= ~IS_R2_F;
-                skge_wakeup(hw->dev[1]);
+                netif_rx_schedule(hw->dev[1]);
         }
 
         if (status & IS_XA1_F)
@@ -2914,6 +2935,7 @@ static irqreturn_t skge_intr(int irq, void *dev_id, struct pt_regs *regs)
         }
 
         skge_write32(hw, B0_IMSK, hw->intr_mask);
+        spin_unlock(&hw->hw_lock);
 
         return IRQ_HANDLED;
 }
@@ -3282,6 +3304,7 @@ static int __devinit skge_probe(struct pci_dev *pdev,
 
         hw->pdev = pdev;
         spin_lock_init(&hw->phy_lock);
+        spin_lock_init(&hw->hw_lock);
         tasklet_init(&hw->ext_tasklet, skge_extirq, (unsigned long) hw);
 
         hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000);
diff --git a/drivers/net/skge.h b/drivers/net/skge.h
index 2efdacc290e5..941f12a333b6 100644
--- a/drivers/net/skge.h
+++ b/drivers/net/skge.h
@@ -2402,6 +2402,7 @@ struct skge_hw {
 
         struct tasklet_struct ext_tasklet;
         spinlock_t           phy_lock;
+        spinlock_t           hw_lock;
 };
 
 enum {
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index cae2edf23004..ca8160d68229 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -195,11 +195,11 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
         pr_debug("sky2_set_power_state %d\n", state);
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
 
-        pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_PMC, &power_control);
+        power_control = sky2_pci_read16(hw, hw->pm_cap + PCI_PM_PMC);
         vaux = (sky2_read16(hw, B0_CTST) & Y2_VAUX_AVAIL) &&
                 (power_control & PCI_PM_CAP_PME_D3cold);
 
-        pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_CTRL, &power_control);
+        power_control = sky2_pci_read16(hw, hw->pm_cap + PCI_PM_CTRL);
 
         power_control |= PCI_PM_CTRL_PME_STATUS;
         power_control &= ~(PCI_PM_CTRL_STATE_MASK);
@@ -223,7 +223,7 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
                         sky2_write8(hw, B2_Y2_CLK_GATE, 0);
 
                 /* Turn off phy power saving */
-                pci_read_config_dword(hw->pdev, PCI_DEV_REG1, &reg1);
+                reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
                 reg1 &= ~(PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD);
 
                 /* looks like this XL is back asswards .. */
@@ -232,18 +232,28 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
                         if (hw->ports > 1)
                                 reg1 |= PCI_Y2_PHY2_COMA;
                 }
-                pci_write_config_dword(hw->pdev, PCI_DEV_REG1, reg1);
+
+                if (hw->chip_id == CHIP_ID_YUKON_EC_U) {
+                        sky2_pci_write32(hw, PCI_DEV_REG3, 0);
+                        reg1 = sky2_pci_read32(hw, PCI_DEV_REG4);
+                        reg1 &= P_ASPM_CONTROL_MSK;
+                        sky2_pci_write32(hw, PCI_DEV_REG4, reg1);
+                        sky2_pci_write32(hw, PCI_DEV_REG5, 0);
+                }
+
+                sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
+
                 break;
 
         case PCI_D3hot:
         case PCI_D3cold:
                 /* Turn on phy power saving */
-                pci_read_config_dword(hw->pdev, PCI_DEV_REG1, &reg1);
+                reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
                 if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
                         reg1 &= ~(PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD);
                 else
                         reg1 |= (PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD);
-                pci_write_config_dword(hw->pdev, PCI_DEV_REG1, reg1);
+                sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
 
                 if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
                         sky2_write8(hw, B2_Y2_CLK_GATE, 0);
@@ -265,7 +275,7 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
                 ret = -1;
         }
 
-        pci_write_config_byte(hw->pdev, hw->pm_cap + PCI_PM_CTRL, power_control);
+        sky2_pci_write16(hw, hw->pm_cap + PCI_PM_CTRL, power_control);
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
         return ret;
 }
@@ -463,16 +473,31 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
                 ledover |= PHY_M_LED_MO_RX(MO_LED_OFF);
         }
 
-        gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl);
+        if (hw->chip_id == CHIP_ID_YUKON_EC_U && hw->chip_rev >= 2) {
+                /* apply fixes in PHY AFE */
+                gm_phy_write(hw, port, 22, 255);
+                /* increase differential signal amplitude in 10BASE-T */
+                gm_phy_write(hw, port, 24, 0xaa99);
+                gm_phy_write(hw, port, 23, 0x2011);
 
-        if (sky2->autoneg == AUTONEG_DISABLE || sky2->speed == SPEED_100) {
-                /* turn on 100 Mbps LED (LED_LINK100) */
-                ledover |= PHY_M_LED_MO_100(MO_LED_ON);
-        }
+                /* fix for IEEE A/B Symmetry failure in 1000BASE-T */
+                gm_phy_write(hw, port, 24, 0xa204);
+                gm_phy_write(hw, port, 23, 0x2002);
 
-        if (ledover)
-                gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover);
+                /* set page register to 0 */
+                gm_phy_write(hw, port, 22, 0);
+        } else {
+                gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl);
+
+                if (sky2->autoneg == AUTONEG_DISABLE || sky2->speed == SPEED_100) {
+                        /* turn on 100 Mbps LED (LED_LINK100) */
+                        ledover |= PHY_M_LED_MO_100(MO_LED_ON);
+                }
+
+                if (ledover)
+                        gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover);
 
+        }
         /* Enable phy interrupt on auto-negotiation complete (or link up) */
         if (sky2->autoneg == AUTONEG_ENABLE)
                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_AN_COMPL);
@@ -520,10 +545,16 @@ static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
 
                 switch (sky2->speed) {
                 case SPEED_1000:
+                        reg &= ~GM_GPCR_SPEED_100;
                         reg |= GM_GPCR_SPEED_1000;
-                        /* fallthru */
+                        break;
                 case SPEED_100:
+                        reg &= ~GM_GPCR_SPEED_1000;
                         reg |= GM_GPCR_SPEED_100;
+                        break;
+                case SPEED_10:
+                        reg &= ~(GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100);
+                        break;
                 }
 
                 if (sky2->duplex == DUPLEX_FULL)
@@ -947,6 +978,12 @@ static int sky2_rx_start(struct sky2_port *sky2)
 
         sky2->rx_put = sky2->rx_next = 0;
         sky2_qset(hw, rxq);
+
+        if (hw->chip_id == CHIP_ID_YUKON_EC_U && hw->chip_rev >= 2) {
+                /* MAC Rx RAM Read is controlled by hardware */
+                sky2_write32(hw, Q_ADDR(rxq, Q_F), F_M_RX_RAM_DIS);
+        }
+
         sky2_prefetch_init(hw, rxq, sky2->rx_le_map, RX_LE_SIZE - 1);
 
         rx_set_checksum(sky2);
@@ -1029,9 +1066,10 @@ static int sky2_up(struct net_device *dev)
                     RB_RST_SET);
 
         sky2_qset(hw, txqaddr[port]);
-        if (hw->chip_id == CHIP_ID_YUKON_EC_U)
-                sky2_write16(hw, Q_ADDR(txqaddr[port], Q_AL), 0x1a0);
 
+        /* Set almost empty threshold */
+        if (hw->chip_id == CHIP_ID_YUKON_EC_U && hw->chip_rev == 1)
+                sky2_write16(hw, Q_ADDR(txqaddr[port], Q_AL), 0x1a0);
 
         sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map,
                            TX_RING_SIZE - 1);
@@ -1041,8 +1079,10 @@ static int sky2_up(struct net_device *dev)
                 goto err_out;
 
         /* Enable interrupts from phy/mac for port */
+        spin_lock_irq(&hw->hw_lock);
         hw->intr_mask |= (port == 0) ? Y2_IS_PORT_1 : Y2_IS_PORT_2;
         sky2_write32(hw, B0_IMSK, hw->intr_mask);
+        spin_unlock_irq(&hw->hw_lock);
         return 0;
 
 err_out:
@@ -1342,10 +1382,10 @@ static int sky2_down(struct net_device *dev)
         netif_stop_queue(dev);
 
         /* Disable port IRQ */
-        local_irq_disable();
+        spin_lock_irq(&hw->hw_lock);
         hw->intr_mask &= ~((sky2->port == 0) ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2);
         sky2_write32(hw, B0_IMSK, hw->intr_mask);
-        local_irq_enable();
+        spin_unlock_irq(&hw->hw_lock);
 
         flush_scheduled_work();
 
@@ -1446,6 +1486,29 @@ static void sky2_link_up(struct sky2_port *sky2)
         sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), GMAC_DEF_MSK);
 
         reg = gma_read16(hw, port, GM_GP_CTRL);
+        if (sky2->autoneg == AUTONEG_DISABLE) {
+                reg |= GM_GPCR_AU_ALL_DIS;
+
+                /* Is write/read necessary?  Copied from sky2_mac_init */
+                gma_write16(hw, port, GM_GP_CTRL, reg);
+                gma_read16(hw, port, GM_GP_CTRL);
+
+                switch (sky2->speed) {
+                case SPEED_1000:
+                        reg &= ~GM_GPCR_SPEED_100;
+                        reg |= GM_GPCR_SPEED_1000;
+                        break;
+                case SPEED_100:
+                        reg &= ~GM_GPCR_SPEED_1000;
+                        reg |= GM_GPCR_SPEED_100;
+                        break;
+                case SPEED_10:
+                        reg &= ~(GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100);
+                        break;
+                }
+        } else
+                reg &= ~GM_GPCR_AU_ALL_DIS;
+
         if (sky2->duplex == DUPLEX_FULL || sky2->autoneg == AUTONEG_ENABLE)
                 reg |= GM_GPCR_DUP_FULL;
 
@@ -1604,10 +1667,10 @@ static void sky2_phy_task(void *arg)
 out:
         up(&sky2->phy_sema);
 
-        local_irq_disable();
+        spin_lock_irq(&hw->hw_lock);
         hw->intr_mask |= (sky2->port == 0) ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2;
         sky2_write32(hw, B0_IMSK, hw->intr_mask);
-        local_irq_enable();
+        spin_unlock_irq(&hw->hw_lock);
 }
 
 
@@ -1834,6 +1897,17 @@ static int sky2_poll(struct net_device *dev0, int *budget)
 
         sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
 
+        /*
+         * Kick the STAT_LEV_TIMER_CTRL timer.
+         * This fixes my hangs on Yukon-EC (0xb6) rev 1.
+         * The if clause is there to start the timer only if it has been
+         * configured correctly and not been disabled via ethtool.
+         */
+        if (sky2_read8(hw, STAT_LEV_TIMER_CTRL) == TIM_START) {
+                sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_STOP);
+                sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START);
+        }
+
         hwidx = sky2_read16(hw, STAT_PUT_IDX);
         BUG_ON(hwidx >= STATUS_RING_SIZE);
         rmb();
@@ -1916,16 +1990,19 @@ exit_loop:
         sky2_tx_check(hw, 0, tx_done[0]);
         sky2_tx_check(hw, 1, tx_done[1]);
 
+        if (sky2_read8(hw, STAT_TX_TIMER_CTRL) == TIM_START) {
+                sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
+                sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
+        }
+
         if (likely(work_done < to_do)) {
-                /* need to restart TX timer */
-                if (is_ec_a1(hw)) {
-                        sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
-                        sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
-                }
+                spin_lock_irq(&hw->hw_lock);
+                __netif_rx_complete(dev0);
 
-                netif_rx_complete(dev0);
                 hw->intr_mask |= Y2_IS_STAT_BMU;
                 sky2_write32(hw, B0_IMSK, hw->intr_mask);
+                spin_unlock_irq(&hw->hw_lock);
+
                 return 0;
         } else {
                 *budget -= work_done;
@@ -1988,13 +2065,13 @@ static void sky2_hw_intr(struct sky2_hw *hw)
         if (status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) {
                 u16 pci_err;
 
-                pci_read_config_word(hw->pdev, PCI_STATUS, &pci_err);
+                pci_err = sky2_pci_read16(hw, PCI_STATUS);
                 if (net_ratelimit())
                         printk(KERN_ERR PFX "%s: pci hw error (0x%x)\n",
                                pci_name(hw->pdev), pci_err);
 
                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
-                pci_write_config_word(hw->pdev, PCI_STATUS,
+                sky2_pci_write16(hw, PCI_STATUS,
                                       pci_err | PCI_STATUS_ERROR_BITS);
                 sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
         }
@@ -2003,7 +2080,7 @@ static void sky2_hw_intr(struct sky2_hw *hw)
                 /* PCI-Express uncorrectable Error occurred */
                 u32 pex_err;
 
-                pci_read_config_dword(hw->pdev, PEX_UNC_ERR_STAT, &pex_err);
+                pex_err = sky2_pci_read32(hw, PEX_UNC_ERR_STAT);
 
                 if (net_ratelimit())
                         printk(KERN_ERR PFX "%s: pci express error (0x%x)\n",
@@ -2011,7 +2088,7 @@ static void sky2_hw_intr(struct sky2_hw *hw)
 
                 /* clear the interrupt */
                 sky2_write32(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
-                pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT,
+                sky2_pci_write32(hw, PEX_UNC_ERR_STAT,
                                        0xffffffffUL);
                 sky2_write32(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
 
@@ -2057,6 +2134,7 @@ static void sky2_phy_intr(struct sky2_hw *hw, unsigned port)
 
         hw->intr_mask &= ~(port == 0 ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2);
         sky2_write32(hw, B0_IMSK, hw->intr_mask);
+
         schedule_work(&sky2->phy_task);
 }
 
@@ -2070,6 +2148,7 @@ static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs)
         if (status == 0 || status == ~0)
                 return IRQ_NONE;
 
+        spin_lock(&hw->hw_lock);
         if (status & Y2_IS_HW_ERR)
                 sky2_hw_intr(hw);
 
@@ -2098,7 +2177,7 @@ static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs)
 
         sky2_write32(hw, B0_Y2_SP_ICR, 2);
 
-        sky2_read32(hw, B0_IMSK);
+        spin_unlock(&hw->hw_lock);
 
         return IRQ_HANDLED;
 }
@@ -2141,7 +2220,7 @@ static int sky2_reset(struct sky2_hw *hw)
 {
         u16 status;
         u8 t8, pmd_type;
-        int i, err;
+        int i;
 
         sky2_write8(hw, B0_CTST, CS_RST_CLR);
 
@@ -2163,25 +2242,18 @@ static int sky2_reset(struct sky2_hw *hw)
         sky2_write8(hw, B0_CTST, CS_RST_CLR);
 
         /* clear PCI errors, if any */
-        err = pci_read_config_word(hw->pdev, PCI_STATUS, &status);
-        if (err)
-                goto pci_err;
+        status = sky2_pci_read16(hw, PCI_STATUS);
 
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
-        err = pci_write_config_word(hw->pdev, PCI_STATUS,
-                                    status | PCI_STATUS_ERROR_BITS);
-        if (err)
-                goto pci_err;
+        sky2_pci_write16(hw, PCI_STATUS, status | PCI_STATUS_ERROR_BITS);
+
 
         sky2_write8(hw, B0_CTST, CS_MRST_CLR);
 
         /* clear any PEX errors */
-        if (pci_find_capability(hw->pdev, PCI_CAP_ID_EXP)) {
-                err = pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT,
-                                                 0xffffffffUL);
-                if (err)
-                        goto pci_err;
-        }
+        if (pci_find_capability(hw->pdev, PCI_CAP_ID_EXP)) 
+                sky2_pci_write32(hw, PEX_UNC_ERR_STAT, 0xffffffffUL);
+
 
         pmd_type = sky2_read8(hw, B2_PMD_TYP);
         hw->copper = !(pmd_type == 'L' || pmd_type == 'S');
@@ -2280,8 +2352,7 @@ static int sky2_reset(struct sky2_hw *hw)
                         sky2_write8(hw, STAT_FIFO_ISR_WM, 16);
 
                 sky2_write32(hw, STAT_TX_TIMER_INI, sky2_us2clk(hw, 1000));
-                sky2_write32(hw, STAT_LEV_TIMER_INI, sky2_us2clk(hw, 100));
-                sky2_write32(hw, STAT_ISR_TIMER_INI, sky2_us2clk(hw, 20));
+                sky2_write32(hw, STAT_ISR_TIMER_INI, sky2_us2clk(hw, 7));
         }
 
         /* enable status unit */
@@ -2292,14 +2363,6 @@ static int sky2_reset(struct sky2_hw *hw)
         sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
 
         return 0;
-
-pci_err:
-        /* This is to catch a BIOS bug workaround where
-         * mmconfig table doesn't have other buses.
-         */
-        printk(KERN_ERR PFX "%s: can't access PCI config space\n",
-               pci_name(hw->pdev));
-        return err;
 }
 
 static u32 sky2_supported_modes(const struct sky2_hw *hw)
@@ -2823,11 +2886,11 @@ static int sky2_set_coalesce(struct net_device *dev,
             (ecmd->rx_coalesce_usecs_irq < tmin || ecmd->rx_coalesce_usecs_irq > tmax))
                 return -EINVAL;
 
-        if (ecmd->tx_max_coalesced_frames > 0xffff)
+        if (ecmd->tx_max_coalesced_frames >= TX_RING_SIZE-1)
                 return -EINVAL;
-        if (ecmd->rx_max_coalesced_frames > 0xff)
+        if (ecmd->rx_max_coalesced_frames > RX_MAX_PENDING)
                 return -EINVAL;
-        if (ecmd->rx_max_coalesced_frames_irq > 0xff)
+        if (ecmd->rx_max_coalesced_frames_irq >RX_MAX_PENDING)
                 return -EINVAL;
 
         if (ecmd->tx_coalesce_usecs == 0)
@@ -3169,17 +3232,6 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                 }
         }
 
-#ifdef __BIG_ENDIAN
-        /* byte swap descriptors in hardware */
-        {
-                u32 reg;
-
-                pci_read_config_dword(pdev, PCI_DEV_REG2, &reg);
-                reg |= PCI_REV_DESC;
-                pci_write_config_dword(pdev, PCI_DEV_REG2, reg);
-        }
-#endif
-
         err = -ENOMEM;
         hw = kzalloc(sizeof(*hw), GFP_KERNEL);
         if (!hw) {
@@ -3197,6 +3249,18 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                 goto err_out_free_hw;
         }
         hw->pm_cap = pm_cap;
+        spin_lock_init(&hw->hw_lock);
+
+#ifdef __BIG_ENDIAN
+        /* byte swap descriptors in hardware */
+        {
+                u32 reg;
+
+                reg = sky2_pci_read32(hw, PCI_DEV_REG2);
+                reg |= PCI_REV_DESC;
+                sky2_pci_write32(hw, PCI_DEV_REG2, reg);
+        }
+#endif
 
         /* ring for status responses */
         hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES,
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index fd12c289a238..3edb98075e0a 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -5,14 +5,22 @@
 #define _SKY2_H
 
 /* PCI config registers */
-#define PCI_DEV_REG1    0x40
-#define PCI_DEV_REG2    0x44
-#define PCI_DEV_STATUS  0x7c
-#define PCI_OS_PCI_X    (1<<26)
+enum {
+        PCI_DEV_REG1    = 0x40,
+        PCI_DEV_REG2    = 0x44,
+        PCI_DEV_STATUS  = 0x7c,
+        PCI_DEV_REG3    = 0x80,
+        PCI_DEV_REG4    = 0x84,
+        PCI_DEV_REG5    = 0x88,
+};
 
-#define PEX_LNK_STAT    0xf2
-#define PEX_UNC_ERR_STAT 0x104
-#define PEX_DEV_CTRL    0xe8
+enum {
+        PEX_DEV_CAP     = 0xe4,
+        PEX_DEV_CTRL    = 0xe8,
+        PEX_DEV_STA     = 0xea,
+        PEX_LNK_STAT    = 0xf2,
+        PEX_UNC_ERR_STAT= 0x104,
+};
 
 /* Yukon-2 */
 enum pci_dev_reg_1 {
@@ -37,6 +45,25 @@ enum pci_dev_reg_2 {
         PCI_USEDATA64   = 1<<0,         /* Use 64Bit Data bus ext */
 };
 
+/*      PCI_OUR_REG_4           32 bit  Our Register 4 (Yukon-ECU only) */
+enum pci_dev_reg_4 {
+                                        /* (Link Training & Status State Machine) */
+        P_TIMER_VALUE_MSK       = 0xffL<<16,    /* Bit 23..16:  Timer Value Mask */
+                                        /* (Active State Power Management) */
+        P_FORCE_ASPM_REQUEST    = 1<<15, /* Force ASPM Request (A1 only) */
+        P_ASPM_GPHY_LINK_DOWN   = 1<<14, /* GPHY Link Down (A1 only) */
+        P_ASPM_INT_FIFO_EMPTY   = 1<<13, /* Internal FIFO Empty (A1 only) */
+        P_ASPM_CLKRUN_REQUEST   = 1<<12, /* CLKRUN Request (A1 only) */
+
+        P_ASPM_FORCE_CLKREQ_ENA = 1<<4, /* Force CLKREQ Enable (A1b only) */
+        P_ASPM_CLKREQ_PAD_CTL   = 1<<3, /* CLKREQ PAD Control (A1 only) */
+        P_ASPM_A1_MODE_SELECT   = 1<<2, /* A1 Mode Select (A1 only) */
+        P_CLK_GATE_PEX_UNIT_ENA = 1<<1, /* Enable Gate PEX Unit Clock */
+        P_CLK_GATE_ROOT_COR_ENA = 1<<0, /* Enable Gate Root Core Clock */
+        P_ASPM_CONTROL_MSK      = P_FORCE_ASPM_REQUEST | P_ASPM_GPHY_LINK_DOWN
+                                  | P_ASPM_CLKRUN_REQUEST | P_ASPM_INT_FIFO_EMPTY,
+};
+
 
 #define PCI_STATUS_ERROR_BITS (PCI_STATUS_DETECTED_PARITY | \
                                PCI_STATUS_SIG_SYSTEM_ERROR | \
@@ -507,6 +534,16 @@ enum {
 };
 #define Q_ADDR(reg, offs) (B8_Q_REGS + (reg) + (offs))
 
+/*      Q_F                             32 bit  Flag Register */
+enum {
+        F_ALM_FULL      = 1<<27, /* Rx FIFO: almost full */
+        F_EMPTY         = 1<<27, /* Tx FIFO: empty flag */
+        F_FIFO_EOF      = 1<<26, /* Tag (EOF Flag) bit in FIFO */
+        F_WM_REACHED    = 1<<25, /* Watermark reached */
+        F_M_RX_RAM_DIS  = 1<<24, /* MAC Rx RAM Read Port disable */
+        F_FIFO_LEVEL    = 0x1fL<<16, /* Bit 23..16:     # of Qwords in FIFO */
+        F_WATER_MARK    = 0x0007ffL, /* Bit 10.. 0:     Watermark */
+};
 
 /* Queue Prefetch Unit Offsets, use Y2_QADDR() to address (Yukon-2 only)*/
 enum {
@@ -909,10 +946,12 @@ enum {
         PHY_BCOM_ID1_C0 = 0x6044,
         PHY_BCOM_ID1_C5 = 0x6047,
 
-        PHY_MARV_ID1_B0 = 0x0C23, /* Yukon (PHY 88E1011) */
+        PHY_MARV_ID1_B0 = 0x0C23, /* Yukon      (PHY 88E1011) */
         PHY_MARV_ID1_B2 = 0x0C25, /* Yukon-Plus (PHY 88E1011) */
-        PHY_MARV_ID1_C2 = 0x0CC2, /* Yukon-EC (PHY 88E1111) */
-        PHY_MARV_ID1_Y2 = 0x0C91, /* Yukon-2 (PHY 88E1112) */
+        PHY_MARV_ID1_C2 = 0x0CC2, /* Yukon-EC   (PHY 88E1111) */
+        PHY_MARV_ID1_Y2 = 0x0C91, /* Yukon-2    (PHY 88E1112) */
+        PHY_MARV_ID1_FE = 0x0C83, /* Yukon-FE   (PHY 88E3082 Rev.A1) */
+        PHY_MARV_ID1_ECU= 0x0CB0, /* Yukon-ECU  (PHY 88E1149 Rev.B2?) */
 };
 
 /* Advertisement register bits */
@@ -1837,8 +1876,9 @@ struct sky2_port {
 struct sky2_hw {
         void __iomem         *regs;
         struct pci_dev       *pdev;
-        u32                  intr_mask;
         struct net_device    *dev[2];
+        spinlock_t           hw_lock;
+        u32                  intr_mask;
 
         int                  pm_cap;
         int                  msi;
@@ -1912,4 +1952,25 @@ static inline void gma_set_addr(struct sky2_hw *hw, unsigned port, unsigned reg,
         gma_write16(hw, port, reg+4,(u16) addr[2] | ((u16) addr[3] << 8));
         gma_write16(hw, port, reg+8,(u16) addr[4] | ((u16) addr[5] << 8));
 }
+
+/* PCI config space access */
+static inline u32 sky2_pci_read32(const struct sky2_hw *hw, unsigned reg)
+{
+        return sky2_read32(hw, Y2_CFG_SPC + reg);
+}
+
+static inline u16 sky2_pci_read16(const struct sky2_hw *hw, unsigned reg)
+{
+        return sky2_read16(hw, Y2_CFG_SPC + reg);
+}
+
+static inline void sky2_pci_write32(struct sky2_hw *hw, unsigned reg, u32 val)
+{
+        sky2_write32(hw, Y2_CFG_SPC + reg, val);
+}
+
+static inline void sky2_pci_write16(struct sky2_hw *hw, unsigned reg, u16 val)
+{
+        sky2_write16(hw, Y2_CFG_SPC + reg, val);
+}
 #endif
diff --git a/drivers/net/tlan.c b/drivers/net/tlan.c
index c2506b56a186..12076f8f942c 100644
--- a/drivers/net/tlan.c
+++ b/drivers/net/tlan.c
@@ -536,6 +536,7 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
         u16                device_id;
         int                reg, rc = -ENODEV;
 
+#ifdef CONFIG_PCI
         if (pdev) {
                 rc = pci_enable_device(pdev);
                 if (rc)
@@ -547,6 +548,7 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                         goto err_out;
                 }
         }
+#endif  /*  CONFIG_PCI  */
 
         dev = alloc_etherdev(sizeof(TLanPrivateInfo));
         if (dev == NULL) {
diff --git a/drivers/net/tokenring/smctr.h b/drivers/net/tokenring/smctr.h
index b306c7e4c793..88dfa2e01d6e 100644
--- a/drivers/net/tokenring/smctr.h
+++ b/drivers/net/tokenring/smctr.h
@@ -1042,7 +1042,7 @@ typedef struct net_local {
         __u16            functional_address[2];
         __u16            bitwise_group_address[2];
 
-        __u8            *ptr_ucode;
+        const __u8       *ptr_ucode;
 
         __u8            cleanup;
 
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index 98a76f10a0f7..dfc24016ba81 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -1872,7 +1872,7 @@ static int atmel_set_encodeext(struct net_device *dev,
         struct atmel_private *priv = netdev_priv(dev);
         struct iw_point *encoding = &wrqu->encoding;
         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
-        int idx, key_len;
+        int idx, key_len, alg = ext->alg, set_key = 1;
 
         /* Determine and validate the key index */
         idx = encoding->flags & IW_ENCODE_INDEX;
@@ -1883,39 +1883,42 @@ static int atmel_set_encodeext(struct net_device *dev,
         } else
                 idx = priv->default_key;
 
-        if ((encoding->flags & IW_ENCODE_DISABLED) ||
-            ext->alg == IW_ENCODE_ALG_NONE) {
-                priv->wep_is_on = 0;
-                priv->encryption_level = 0;
-                priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
-        }
+        if (encoding->flags & IW_ENCODE_DISABLED)
+            alg = IW_ENCODE_ALG_NONE;
 
-        if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
+        if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
                 priv->default_key = idx;
+                set_key = ext->key_len > 0 ? 1 : 0;
+        }
 
-        /* Set the requested key */
-        switch (ext->alg) {
-        case IW_ENCODE_ALG_NONE:
-                break;
-        case IW_ENCODE_ALG_WEP:
-                if (ext->key_len > 5) {
-                        priv->wep_key_len[idx] = 13;
-                        priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
-                        priv->encryption_level = 2;
-                } else if (ext->key_len > 0) {
-                        priv->wep_key_len[idx] = 5;
-                        priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
-                        priv->encryption_level = 1;
-                } else {
+        if (set_key) {
+                /* Set the requested key first */
+                switch (alg) {
+                case IW_ENCODE_ALG_NONE:
+                        priv->wep_is_on = 0;
+                        priv->encryption_level = 0;
+                        priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
+                        break;
+                case IW_ENCODE_ALG_WEP:
+                        if (ext->key_len > 5) {
+                                priv->wep_key_len[idx] = 13;
+                                priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
+                                priv->encryption_level = 2;
+                        } else if (ext->key_len > 0) {
+                                priv->wep_key_len[idx] = 5;
+                                priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
+                                priv->encryption_level = 1;
+                        } else {
+                                return -EINVAL;
+                        }
+                        priv->wep_is_on = 1;
+                        memset(priv->wep_keys[idx], 0, 13);
+                        key_len = min ((int)ext->key_len, priv->wep_key_len[idx]);
+                        memcpy(priv->wep_keys[idx], ext->key, key_len);
+                        break;
+                default:
                         return -EINVAL;
                 }
-                priv->wep_is_on = 1;
-                memset(priv->wep_keys[idx], 0, 13);
-                key_len = min ((int)ext->key_len, priv->wep_key_len[idx]);
-                memcpy(priv->wep_keys[idx], ext->key, key_len);
-                break;
-        default:
-                return -EINVAL;
         }
 
         return -EINPROGRESS;
@@ -3061,17 +3064,26 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
         }
 
         if (status == C80211_MGMT_SC_Success && priv->wep_is_on) {
+                int should_associate = 0;
                 /* WEP */
                 if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum)
                         return;
 
-                if (trans_seq_no == 0x0002 &&
-                    auth->el_id == C80211_MGMT_ElementID_ChallengeText) {
-                        send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len);
-                        return;
+                if (system == C80211_MGMT_AAN_OPENSYSTEM) {
+                        if (trans_seq_no == 0x0002) {
+                                should_associate = 1;
+                        }
+                } else if (system == C80211_MGMT_AAN_SHAREDKEY) {
+                        if (trans_seq_no == 0x0002 &&
+                            auth->el_id == C80211_MGMT_ElementID_ChallengeText) {
+                                send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len);
+                                return;
+                        } else if (trans_seq_no == 0x0004) {
+                                should_associate = 1;
+                        }
                 }
 
-                if (trans_seq_no == 0x0004) {
+                if (should_associate) {
                         if(priv->station_was_associated) {
                                 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
                                 send_association_request(priv, 1);
@@ -3084,11 +3096,13 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
                 }
         }
 
-        if (status == C80211_MGMT_SC_AuthAlgNotSupported) {
+        if (status == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
                 /* Do opensystem first, then try sharedkey */
-                if (system ==  C80211_MGMT_AAN_OPENSYSTEM) {
+                if (system == WLAN_AUTH_OPEN) {
                         priv->CurrentAuthentTransactionSeqNum = 0x001;
-                        send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0);
+                        priv->exclude_unencrypted = 1;
+                        send_authentication_request(priv, WLAN_AUTH_SHARED_KEY, NULL, 0);
+                        return;
                 } else if (priv->connect_to_any_BSS) {
                         int bss_index;
 
@@ -3439,10 +3453,13 @@ static void atmel_management_timer(u_long a)
                         priv->AuthenticationRequestRetryCnt = 0;
                         restart_search(priv);
                 } else {
+                        int auth = C80211_MGMT_AAN_OPENSYSTEM;
                         priv->AuthenticationRequestRetryCnt++;
                         priv->CurrentAuthentTransactionSeqNum = 0x0001;
                         mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
-                        send_authentication_request(priv, C80211_MGMT_AAN_OPENSYSTEM, NULL, 0);
+                        if (priv->wep_is_on && priv->exclude_unencrypted)
+                                auth = C80211_MGMT_AAN_SHAREDKEY;
+                        send_authentication_request(priv, auth, NULL, 0);
           }
           break;
 
@@ -3541,12 +3558,15 @@ static void atmel_command_irq(struct atmel_private *priv)
                                 priv->station_was_associated = priv->station_is_associated;
                                 atmel_enter_state(priv, STATION_STATE_READY);
                         } else {
+                                int auth = C80211_MGMT_AAN_OPENSYSTEM;
                                 priv->AuthenticationRequestRetryCnt = 0;
                                 atmel_enter_state(priv, STATION_STATE_AUTHENTICATING);
 
                                 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
                                 priv->CurrentAuthentTransactionSeqNum = 0x0001;
-                                send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0);
+                                if (priv->wep_is_on && priv->exclude_unencrypted)
+                                        auth = C80211_MGMT_AAN_SHAREDKEY;
+                                send_authentication_request(priv, auth, NULL, 0);
                         }
                         return;
                 }
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index 0702f0eeb784..44024c76d187 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -4636,9 +4636,9 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                 }
 
         default:
-                IPW_ERROR("Unknown notification: "
-                          "subtype=%d,flags=0x%2x,size=%d\n",
-                          notif->subtype, notif->flags, notif->size);
+                IPW_DEBUG_NOTIF("Unknown notification: "
+                                "subtype=%d,flags=0x%2x,size=%d\n",
+                                notif->subtype, notif->flags, notif->size);
         }
 }
 
diff --git a/drivers/net/wireless/wavelan_cs.c b/drivers/net/wireless/wavelan_cs.c
index cf373625fc70..98122f3a4bc2 100644
--- a/drivers/net/wireless/wavelan_cs.c
+++ b/drivers/net/wireless/wavelan_cs.c
@@ -950,16 +950,8 @@ wv_82593_cmd(struct net_device *	dev,
 static inline int
 wv_diag(struct net_device *     dev)
 {
-  int           ret = FALSE;
-
-  if(wv_82593_cmd(dev, "wv_diag(): diagnose",
-                  OP0_DIAGNOSE, SR0_DIAGNOSE_PASSED))
-    ret = TRUE;
-
-#ifdef DEBUG_CONFIG_ERRORS
-  printk(KERN_INFO "wavelan_cs: i82593 Self Test failed!\n");
-#endif
-  return(ret);
+  return(wv_82593_cmd(dev, "wv_diag(): diagnose",
+                      OP0_DIAGNOSE, SR0_DIAGNOSE_PASSED));
 } /* wv_diag */
 
 /*------------------------------------------------------------------*/
@@ -3604,8 +3596,8 @@ wv_82593_config(struct net_device *	dev)
   cfblk.lin_prio = 0;           /* conform to 802.3 backoff algoritm */
   cfblk.exp_prio = 5;           /* conform to 802.3 backoff algoritm */
   cfblk.bof_met = 1;            /* conform to 802.3 backoff algoritm */
-  cfblk.ifrm_spc = 0x20;        /* 32 bit times interframe spacing */
-  cfblk.slottim_low = 0x20;     /* 32 bit times slot time */
+  cfblk.ifrm_spc = 0x20 >> 4;   /* 32 bit times interframe spacing */
+  cfblk.slottim_low = 0x20 >> 5;        /* 32 bit times slot time */
   cfblk.slottim_hi = 0x0;
   cfblk.max_retr = 15;
   cfblk.prmisc = ((lp->promiscuous) ? TRUE: FALSE);     /* Promiscuous mode */
diff --git a/drivers/s390/block/Kconfig b/drivers/s390/block/Kconfig
index 6912399d0937..6f50cc9323d9 100644
--- a/drivers/s390/block/Kconfig
+++ b/drivers/s390/block/Kconfig
@@ -55,21 +55,13 @@ config DASD_DIAG
           Disks under VM.  If you are not running under VM or unsure what it is,
           say "N".
 
-config DASD_EER
-        tristate "Extended error reporting (EER)"
-        depends on DASD
-        help
-          This driver provides a character device interface to the
-          DASD extended error reporting. This is only needed if you want to
-          use applications written for the EER facility.
-
 config DASD_CMB
         tristate "Compatibility interface for DASD channel measurement blocks"
         depends on DASD
         help
-          This driver provides an additional interface to the channel
-          measurement facility, which is normally accessed though sysfs, with
-          a set of ioctl functions specific to the dasd driver.
+          This driver provides an additional interface to the channel measurement
+          facility, which is normally accessed though sysfs, with a set of
+          ioctl functions specific to the dasd driver.
           This is only needed if you want to use applications written for
           linux-2.4 dasd channel measurement facility interface.
 
diff --git a/drivers/s390/block/Makefile b/drivers/s390/block/Makefile
index 0c0d871e8f51..58c6780134f7 100644
--- a/drivers/s390/block/Makefile
+++ b/drivers/s390/block/Makefile
@@ -5,7 +5,6 @@
 dasd_eckd_mod-objs := dasd_eckd.o dasd_3990_erp.o dasd_9343_erp.o
 dasd_fba_mod-objs  := dasd_fba.o dasd_3370_erp.o dasd_9336_erp.o
 dasd_diag_mod-objs := dasd_diag.o
-dasd_eer_mod-objs := dasd_eer.o
 dasd_mod-objs      := dasd.o dasd_ioctl.o dasd_proc.o dasd_devmap.o \
                         dasd_genhd.o dasd_erp.o
 
@@ -14,6 +13,5 @@ obj-$(CONFIG_DASD_DIAG) += dasd_diag_mod.o
 obj-$(CONFIG_DASD_ECKD) += dasd_eckd_mod.o
 obj-$(CONFIG_DASD_FBA)  += dasd_fba_mod.o
 obj-$(CONFIG_DASD_CMB)  += dasd_cmb.o
-obj-$(CONFIG_DASD_EER)  += dasd_eer.o
 obj-$(CONFIG_BLK_DEV_XPRAM) += xpram.o
 obj-$(CONFIG_DCSSBLK) += dcssblk.o
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 08c88fcd8963..af1d5b404cee 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -18,7 +18,6 @@
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/hdreg.h>
-#include <linux/notifier.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
@@ -58,7 +57,6 @@ static void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
 static void dasd_flush_ccw_queue(struct dasd_device *, int);
 static void dasd_tasklet(struct dasd_device *);
 static void do_kick_device(void *data);
-static void dasd_disable_eer(struct dasd_device *device);
 
 /*
  * SECTION: Operations on the device structure.
@@ -153,10 +151,13 @@ dasd_state_new_to_known(struct dasd_device *device)
 static inline void
 dasd_state_known_to_new(struct dasd_device * device)
 {
-        /* disable extended error reporting for this device */
-        dasd_disable_eer(device);
         /* Forget the discipline information. */
+        if (device->discipline)
+                module_put(device->discipline->owner);
         device->discipline = NULL;
+        if (device->base_discipline)
+                module_put(device->base_discipline->owner);
+        device->base_discipline = NULL;
         device->state = DASD_STATE_NEW;
 
         dasd_free_queue(device);
@@ -871,9 +872,6 @@ dasd_handle_state_change_pending(struct dasd_device *device)
         struct dasd_ccw_req *cqr;
         struct list_head *l, *n;
 
-        /* first of all call extended error reporting */
-        dasd_write_eer_trigger(DASD_EER_STATECHANGE, device, NULL);
-
         device->stopped &= ~DASD_STOPPED_PENDING;
 
         /* restart all 'running' IO on queue */
@@ -1093,19 +1091,6 @@ restart:
                         }
                         goto restart;
                 }
-
-                /* first of all call extended error reporting */
-                if (device->eer && cqr->status == DASD_CQR_FAILED) {
-                        dasd_write_eer_trigger(DASD_EER_FATALERROR,
-                                               device, cqr);
-
-                        /* restart request  */
-                        cqr->status = DASD_CQR_QUEUED;
-                        cqr->retries = 255;
-                        device->stopped |= DASD_STOPPED_QUIESCE;
-                        goto restart;
-                }
-
                 /* Process finished ERP request. */
                 if (cqr->refers) {
                         __dasd_process_erp(device, cqr);
@@ -1243,8 +1228,7 @@ __dasd_start_head(struct dasd_device * device)
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, list);
         /* check FAILFAST */
         if (device->stopped & ~DASD_STOPPED_PENDING &&
-            test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
-            (!device->eer)) {
+            test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags)) {
                 cqr->status = DASD_CQR_FAILED;
                 dasd_schedule_bh(device);
         }
@@ -1880,9 +1864,10 @@ dasd_generic_remove (struct ccw_device *cdev)
  */
 int
 dasd_generic_set_online (struct ccw_device *cdev,
-                         struct dasd_discipline *discipline)
+                         struct dasd_discipline *base_discipline)
 
 {
+        struct dasd_discipline *discipline;
         struct dasd_device *device;
         int rc;
 
@@ -1890,6 +1875,7 @@ dasd_generic_set_online (struct ccw_device *cdev,
         if (IS_ERR(device))
                 return PTR_ERR(device);
 
+        discipline = base_discipline;
         if (device->features & DASD_FEATURE_USEDIAG) {
                 if (!dasd_diag_discipline_pointer) {
                         printk (KERN_WARNING
@@ -1901,6 +1887,16 @@ dasd_generic_set_online (struct ccw_device *cdev,
                 }
                 discipline = dasd_diag_discipline_pointer;
         }
+        if (!try_module_get(base_discipline->owner)) {
+                dasd_delete_device(device);
+                return -EINVAL;
+        }
+        if (!try_module_get(discipline->owner)) {
+                module_put(base_discipline->owner);
+                dasd_delete_device(device);
+                return -EINVAL;
+        }
+        device->base_discipline = base_discipline;
         device->discipline = discipline;
 
         rc = discipline->check_device(device);
@@ -1909,6 +1905,8 @@ dasd_generic_set_online (struct ccw_device *cdev,
                         "dasd_generic couldn't online device %s "
                         "with discipline %s rc=%i\n",
                         cdev->dev.bus_id, discipline->name, rc);
+                module_put(discipline->owner);
+                module_put(base_discipline->owner);
                 dasd_delete_device(device);
                 return rc;
         }
@@ -1986,9 +1984,6 @@ dasd_generic_notify(struct ccw_device *cdev, int event)
         switch (event) {
         case CIO_GONE:
         case CIO_NO_PATH:
-                /* first of all call extended error reporting */
-                dasd_write_eer_trigger(DASD_EER_NOPATH, device, NULL);
-
                 if (device->state < DASD_STATE_BASIC)
                         break;
                 /* Device is active. We want to keep it. */
@@ -2046,51 +2041,6 @@ dasd_generic_auto_online (struct ccw_driver *dasd_discipline_driver)
         put_driver(drv);
 }
 
-/*
- * notifications for extended error reports
- */
-static struct notifier_block *dasd_eer_chain;
-
-int
-dasd_register_eer_notifier(struct notifier_block *nb)
-{
-        return notifier_chain_register(&dasd_eer_chain, nb);
-}
-
-int
-dasd_unregister_eer_notifier(struct notifier_block *nb)
-{
-        return notifier_chain_unregister(&dasd_eer_chain, nb);
-}
-
-/*
- * Notify the registered error reporting module of a problem
- */
-void
-dasd_write_eer_trigger(unsigned int id, struct dasd_device *device,
-                       struct dasd_ccw_req *cqr)
-{
-        if (device->eer) {
-                struct dasd_eer_trigger temp;
-                temp.id = id;
-                temp.device = device;
-                temp.cqr = cqr;
-                notifier_call_chain(&dasd_eer_chain, DASD_EER_TRIGGER,
-                                    (void *)&temp);
-        }
-}
-
-/*
- * Tell the registered error reporting module to disable error reporting for
- * a given device and to cleanup any private data structures on that device.
- */
-static void
-dasd_disable_eer(struct dasd_device *device)
-{
-        notifier_call_chain(&dasd_eer_chain, DASD_EER_DISABLE, (void *)device);
-}
-
-
 static int __init
 dasd_init(void)
 {
@@ -2172,11 +2122,6 @@ EXPORT_SYMBOL_GPL(dasd_generic_set_online);
 EXPORT_SYMBOL_GPL(dasd_generic_set_offline);
 EXPORT_SYMBOL_GPL(dasd_generic_auto_online);
 
-EXPORT_SYMBOL(dasd_register_eer_notifier);
-EXPORT_SYMBOL(dasd_unregister_eer_notifier);
-EXPORT_SYMBOL(dasd_write_eer_trigger);
-
-
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index c811380b9079..4ee0f934e325 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -1108,9 +1108,6 @@ dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
                 case 0x0B:
                         DEV_MESSAGE(KERN_WARNING, device, "%s",
                                     "FORMAT F - Volume is suspended duplex");
-                        /* call extended error reporting (EER) */
-                        dasd_write_eer_trigger(DASD_EER_PPRCSUSPEND, device,
-                                               erp->refers);
                         break;
                 case 0x0C:
                         DEV_MESSAGE(KERN_WARNING, device, "%s",
diff --git a/drivers/s390/block/dasd_eckd.h b/drivers/s390/block/dasd_eckd.h
index e15dd7978050..bc3823d35223 100644
--- a/drivers/s390/block/dasd_eckd.h
+++ b/drivers/s390/block/dasd_eckd.h
@@ -29,7 +29,6 @@
 #define DASD_ECKD_CCW_PSF                0x27
 #define DASD_ECKD_CCW_RSSD               0x3e
 #define DASD_ECKD_CCW_LOCATE_RECORD      0x47
-#define DASD_ECKD_CCW_SNSS               0x54
 #define DASD_ECKD_CCW_DEFINE_EXTENT      0x63
 #define DASD_ECKD_CCW_WRITE_MT           0x85
 #define DASD_ECKD_CCW_READ_MT            0x86
diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
deleted file mode 100644
index f70cd7716b24..000000000000
--- a/drivers/s390/block/dasd_eer.c
+++ /dev/null
@@ -1,1090 +0,0 @@
-/*
- *      character device driver for extended error reporting
- *
- *
- *      Copyright (C) 2005 IBM Corporation
- *      extended error reporting for DASD ECKD devices
- *      Author(s): Stefan Weinhuber <wein@de.ibm.com>
- *
- */
-
-#include <linux/init.h>
-#include <linux/fs.h>
-#include <linux/kernel.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/device.h>
-#include <linux/workqueue.h>
-#include <linux/poll.h>
-#include <linux/notifier.h>
-
-#include <asm/uaccess.h>
-#include <asm/semaphore.h>
-#include <asm/atomic.h>
-#include <asm/ebcdic.h>
-
-#include "dasd_int.h"
-#include "dasd_eckd.h"
-
-
-MODULE_LICENSE("GPL");
-
-MODULE_AUTHOR("Stefan Weinhuber <wein@de.ibm.com>");
-MODULE_DESCRIPTION("DASD extended error reporting module");
-
-
-#ifdef PRINTK_HEADER
-#undef PRINTK_HEADER
-#endif                          /* PRINTK_HEADER */
-#define PRINTK_HEADER "dasd(eer):"
-
-
-
-
-
-/*****************************************************************************/
-/*      the internal buffer                                                  */
-/*****************************************************************************/
-
-/*
- * The internal buffer is meant to store obaque blobs of data, so it doesn't
- * know of higher level concepts like triggers.
- * It consists of a number of pages that are used as a ringbuffer. Each data
- * blob is stored in a simple record that consists of an integer, which
- * contains the size of the following data, and the data bytes themselfes.
- *
- * To allow for multiple independent readers we create one internal buffer
- * each time the device is opened and destroy the buffer when the file is
- * closed again.
- *
- * One record can be written to a buffer by using the functions
- * - dasd_eer_start_record (one time per record to write the size to the buffer
- *                          and reserve the space for the data)
- * - dasd_eer_write_buffer (one or more times per record to write the data)
- * The data can be written in several steps but you will have to compute
- * the total size up front for the invocation of dasd_eer_start_record.
- * If the ringbuffer is full, dasd_eer_start_record will remove the required
- * number of old records.
- *
- * A record is typically read in two steps, first read the integer that
- * specifies the size of the following data, then read the data.
- * Both can be done by
- * - dasd_eer_read_buffer
- *
- * For all mentioned functions you need to get the bufferlock first and keep it
- * until a complete record is written or read.
- */
-
-
-/*
- * Alle information necessary to keep track of an internal buffer is kept in
- * a struct eerbuffer. The buffer specific to a file pointer is strored in
- * the private_data field of that file. To be able to write data to all
- * existing buffers, each buffer is also added to the bufferlist.
- * If the user doesn't want to read a complete record in one go, we have to
- * keep track of the rest of the record. residual stores the number of bytes
- * that are still to deliver. If the rest of the record is invalidated between
- * two reads then residual will be set to -1 so that the next read will fail.
- * All entries in the eerbuffer structure are protected with the bufferlock.
- * To avoid races between writing to a buffer on the one side and creating
- * and destroying buffers on the other side, the bufferlock must also be used
- * to protect the bufferlist.
- */
-
-struct eerbuffer {
-        struct list_head list;
-        char **buffer;
-        int buffersize;
-        int buffer_page_count;
-        int head;
-        int tail;
-        int residual;
-};
-
-LIST_HEAD(bufferlist);
-
-static spinlock_t bufferlock = SPIN_LOCK_UNLOCKED;
-
-DECLARE_WAIT_QUEUE_HEAD(dasd_eer_read_wait_queue);
-
-/*
- * How many free bytes are available on the buffer.
- * needs to be called with bufferlock held
- */
-static int
-dasd_eer_get_free_bytes(struct eerbuffer *eerb)
-{
-        if (eerb->head < eerb->tail) {
-                return eerb->tail - eerb->head - 1;
-        } else
-                return eerb->buffersize - eerb->head + eerb->tail -1;
-}
-
-/*
- * How many bytes of buffer space are used.
- * needs to be called with bufferlock held
- */
-static int
-dasd_eer_get_filled_bytes(struct eerbuffer *eerb)
-{
-
-        if (eerb->head >= eerb->tail) {
-                return eerb->head - eerb->tail;
-        } else
-                return eerb->buffersize - eerb->tail + eerb->head;
-}
-
-/*
- * The dasd_eer_write_buffer function just copies count bytes of data
- * to the buffer. Make sure to call dasd_eer_start_record first, to
- * make sure that enough free space is available.
- * needs to be called with bufferlock held
- */
-static void
-dasd_eer_write_buffer(struct eerbuffer *eerb, int count, char *data)
-{
-
-        unsigned long headindex,localhead;
-        unsigned long rest, len;
-        char *nextdata;
-
-        nextdata = data;
-        rest = count;
-        while (rest > 0) {
-                headindex = eerb->head / PAGE_SIZE;
-                localhead = eerb->head % PAGE_SIZE;
-                len = min(rest, (PAGE_SIZE - localhead));
-                memcpy(eerb->buffer[headindex]+localhead, nextdata, len);
-                nextdata += len;
-                rest -= len;
-                eerb->head += len;
-                if ( eerb->head == eerb->buffersize )
-                        eerb->head = 0; /* wrap around */
-                if (eerb->head > eerb->buffersize) {
-                        MESSAGE(KERN_ERR, "%s", "runaway buffer head.");
-                        BUG();
-                }
-        }
-}
-
-/*
- * needs to be called with bufferlock held
- */
-static int
-dasd_eer_read_buffer(struct eerbuffer *eerb, int count, char *data)
-{
-
-        unsigned long tailindex,localtail;
-        unsigned long rest, len, finalcount;
-        char *nextdata;
-
-        finalcount = min(count, dasd_eer_get_filled_bytes(eerb));
-        nextdata = data;
-        rest = finalcount;
-        while (rest > 0) {
-                tailindex = eerb->tail / PAGE_SIZE;
-                localtail = eerb->tail % PAGE_SIZE;
-                len = min(rest, (PAGE_SIZE - localtail));
-                memcpy(nextdata, eerb->buffer[tailindex]+localtail, len);
-                nextdata += len;
-                rest -= len;
-                eerb->tail += len;
-                if ( eerb->tail == eerb->buffersize )
-                        eerb->tail = 0; /* wrap around */
-                if (eerb->tail > eerb->buffersize) {
-                        MESSAGE(KERN_ERR, "%s", "runaway buffer tail.");
-                        BUG();
-                }
-        }
-        return finalcount;
-}
-
-/*
- * Whenever you want to write a blob of data to the internal buffer you
- * have to start by using this function first. It will write the number
- * of bytes that will be written to the buffer. If necessary it will remove
- * old records to make room for the new one.
- * needs to be called with bufferlock held
- */
-static int
-dasd_eer_start_record(struct eerbuffer *eerb, int count)
-{
-        int tailcount;
-        if (count + sizeof(count) > eerb->buffersize)
-                return -ENOMEM;
-        while (dasd_eer_get_free_bytes(eerb) < count + sizeof(count)) {
-                if (eerb->residual > 0) {
-                        eerb->tail += eerb->residual;
-                        if (eerb->tail >= eerb->buffersize)
-                                eerb->tail -= eerb->buffersize;
-                        eerb->residual = -1;
-                }
-                dasd_eer_read_buffer(eerb, sizeof(tailcount),
-                                     (char*)(&tailcount));
-                eerb->tail += tailcount;
-                if (eerb->tail >= eerb->buffersize)
-                        eerb->tail -= eerb->buffersize;
-        }
-        dasd_eer_write_buffer(eerb, sizeof(count), (char*)(&count));
-
-        return 0;
-};
-
-/*
- * release pages that are not used anymore
- */
-static void
-dasd_eer_free_buffer_pages(char **buf, int no_pages)
-{
-        int i;
-
-        for (i = 0; i < no_pages; ++i) {
-                free_page((unsigned long)buf[i]);
-        }
-}
-
-/*
- * allocate a new set of memory pages
- */
-static int
-dasd_eer_allocate_buffer_pages(char **buf, int no_pages)
-{
-        int i;
-
-        for (i = 0; i < no_pages; ++i) {
-                buf[i] = (char *) get_zeroed_page(GFP_KERNEL);
-                if (!buf[i]) {
-                        dasd_eer_free_buffer_pages(buf, i);
-                        return -ENOMEM;
-                }
-        }
-        return 0;
-}
-
-/*
- * empty the buffer by resetting head and tail
- * In case there is a half read data blob in the buffer, we set residual
- * to -1 to indicate that the remainder of the blob is lost.
- */
-static void
-dasd_eer_purge_buffer(struct eerbuffer *eerb)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&bufferlock, flags);
-        if (eerb->residual > 0)
-                eerb->residual = -1;
-        eerb->tail=0;
-        eerb->head=0;
-        spin_unlock_irqrestore(&bufferlock, flags);
-}
-
-/*
- * set the size of the buffer, newsize is the new number of pages to be used
- * we don't try to copy any data back an forth, so any resize will also purge
- * the buffer
- */
-static int
-dasd_eer_resize_buffer(struct eerbuffer *eerb, int newsize)
-{
-        int i, oldcount, reuse;
-        char **new;
-        char **old;
-        unsigned long flags;
-
-        if (newsize < 1)
-                return -EINVAL;
-        if (eerb->buffer_page_count == newsize) {
-                /* documented behaviour is that any successfull invocation
-                 * will purge all records */
-                dasd_eer_purge_buffer(eerb);
-                return 0;
-        }
-        new = kmalloc(newsize*sizeof(char*), GFP_KERNEL);
-        if (!new)
-                return -ENOMEM;
-
-        reuse=min(eerb->buffer_page_count, newsize);
-        for (i = 0; i < reuse; ++i) {
-                new[i] = eerb->buffer[i];
-        }
-        if (eerb->buffer_page_count < newsize) {
-                if (dasd_eer_allocate_buffer_pages(
-                            &new[eerb->buffer_page_count],
-                            newsize - eerb->buffer_page_count)) {
-                        kfree(new);
-                        return -ENOMEM;
-                }
-        }
-
-        spin_lock_irqsave(&bufferlock, flags);
-        old = eerb->buffer;
-        eerb->buffer = new;
-        if (eerb->residual > 0)
-                eerb->residual = -1;
-        eerb->tail = 0;
-        eerb->head = 0;
-        oldcount = eerb->buffer_page_count;
-        eerb->buffer_page_count = newsize;
-        spin_unlock_irqrestore(&bufferlock, flags);
-
-        if (oldcount > newsize) {
-                for (i = newsize; i < oldcount; ++i) {
-                        free_page((unsigned long)old[i]);
-                }
-        }
-        kfree(old);
-
-        return 0;
-}
-
-
-/*****************************************************************************/
-/*      The extended error reporting functionality                           */
-/*****************************************************************************/
-
-/*
- * When a DASD device driver wants to report an error, it calls the
- * function dasd_eer_write_trigger (via a notifier mechanism) and gives the
- * respective trigger ID as parameter.
- * Currently there are four kinds of triggers:
- *
- * DASD_EER_FATALERROR:  all kinds of unrecoverable I/O problems
- * DASD_EER_PPRCSUSPEND: PPRC was suspended
- * DASD_EER_NOPATH:      There is no path to the device left.
- * DASD_EER_STATECHANGE: The state of the device has changed.
- *
- * For the first three triggers all required information can be supplied by
- * the caller. For these triggers a record is written by the function
- * dasd_eer_write_standard_trigger.
- *
- * When dasd_eer_write_trigger is called to write a DASD_EER_STATECHANGE
- * trigger, we have to gather the necessary sense data first. We cannot queue
- * the necessary SNSS (sense subsystem status) request immediatly, since we
- * are likely to run in a deadlock situation. Instead, we schedule a
- * work_struct that calls the function dasd_eer_sense_subsystem_status to
- * create and start an SNSS  request asynchronously.
- *
- * To avoid memory allocations at runtime, the necessary memory is allocated
- * when the extended error reporting is enabled for a device (by
- * dasd_eer_probe). There is one private eer data structure for each eer
- * enabled DASD device. It contains memory for the work_struct, one SNSS cqr
- * and a flags field that is used to coordinate the use of the cqr. The call
- * to write a state change trigger can come in at any time, so we have one flag
- * CQR_IN_USE that protects the cqr itself. When this flag indicates that the
- * cqr is currently in use, dasd_eer_sense_subsystem_status cannot start a
- * second request but sets the SNSS_REQUESTED flag instead.
- *
- * When the request is finished, the callback function dasd_eer_SNSS_cb
- * is called. This function will invoke the function
- * dasd_eer_write_SNSS_trigger to finally write the trigger. It will also
- * check the SNSS_REQUESTED flag and if it is set it will call
- * dasd_eer_sense_subsystem_status again.
- *
- * To avoid race conditions during the handling of the lock, the flags must
- * be protected by the snsslock.
- */
-
-struct dasd_eer_private {
-        struct dasd_ccw_req *cqr;
-        unsigned long flags;
-        struct work_struct worker;
-};
-
-static void dasd_eer_destroy(struct dasd_device *device,
-                             struct dasd_eer_private *eer);
-static int
-dasd_eer_write_trigger(struct dasd_eer_trigger *trigger);
-static void dasd_eer_sense_subsystem_status(void *data);
-static int dasd_eer_notify(struct notifier_block *self,
-                           unsigned long action, void *data);
-
-struct workqueue_struct *dasd_eer_workqueue;
-
-#define SNSS_DATA_SIZE 44
-static spinlock_t snsslock = SPIN_LOCK_UNLOCKED;
-
-#define DASD_EER_BUSID_SIZE 10
-struct dasd_eer_header {
-        __u32 total_size;
-        __u32 trigger;
-        __u64 tv_sec;
-        __u64 tv_usec;
-        char busid[DASD_EER_BUSID_SIZE];
-} __attribute__ ((packed));
-
-static struct notifier_block dasd_eer_nb = {
-        .notifier_call = dasd_eer_notify,
-};
-
-/*
- * flags for use with dasd_eer_private
- */
-#define CQR_IN_USE     0
-#define SNSS_REQUESTED 1
-
-/*
- * This function checks if extended error reporting is available for a given
- * dasd_device. If yes, then it creates and returns a struct dasd_eer,
- * otherwise it returns an -EPERM error pointer.
- */
-struct dasd_eer_private *
-dasd_eer_probe(struct dasd_device *device)
-{
-        struct dasd_eer_private *private;
-
-        if (!(device && device->discipline
-              && !strcmp(device->discipline->name, "ECKD"))) {
-                return ERR_PTR(-EPERM);
-        }
-        /* allocate the private data structure */
-        private = (struct dasd_eer_private *)kmalloc(
-                sizeof(struct dasd_eer_private), GFP_KERNEL);
-        if (!private) {
-                return ERR_PTR(-ENOMEM);
-        }
-        INIT_WORK(&private->worker, dasd_eer_sense_subsystem_status,
-                  (void *)device);
-        private->cqr = dasd_kmalloc_request("ECKD",
-                                            1 /* SNSS */ ,
-                                            SNSS_DATA_SIZE ,
-                                            device);
-        if (!private->cqr) {
-                kfree(private);
-                return ERR_PTR(-ENOMEM);
-        }
-        private->flags = 0;
-        return private;
-};
-
-/*
- * If our private SNSS request is queued, remove it from the
- * dasd ccw queue so we can free the requests memory.
- */
-static void
-dasd_eer_dequeue_SNSS_request(struct dasd_device *device,
-                              struct dasd_eer_private *eer)
-{
-        struct list_head *lst, *nxt;
-        struct dasd_ccw_req *cqr, *erpcqr;
-        dasd_erp_fn_t erp_fn;
-
-        spin_lock_irq(get_ccwdev_lock(device->cdev));
-        list_for_each_safe(lst, nxt, &device->ccw_queue) {
-                cqr = list_entry(lst, struct dasd_ccw_req, list);
-                /* we are looking for two kinds or requests */
-                /* first kind: our SNSS request: */
-                if (cqr == eer->cqr) {
-                        if (cqr->status == DASD_CQR_IN_IO)
-                                device->discipline->term_IO(cqr);
-                        list_del(&cqr->list);
-                        break;
-                }
-                /* second kind: ERP requests for our SNSS request */
-                if (cqr->refers) {
-                        /* If this erp request chain ends in our cqr, then */
-                        /* cal the erp_postaction to clean it up  */
-                        erpcqr = cqr;
-                        while (erpcqr->refers) {
-                                erpcqr = erpcqr->refers;
-                        }
-                        if (erpcqr == eer->cqr) {
-                                erp_fn = device->discipline->erp_postaction(
-                                         cqr);
-                                erp_fn(cqr);
-                        }
-                        continue;
-                }
-        }
-        spin_unlock_irq(get_ccwdev_lock(device->cdev));
-}
-
-/*
- * This function dismantles a struct dasd_eer that was created by
- * dasd_eer_probe. Since we want to free our private data structure,
- * we must make sure that the memory is not in use anymore.
- * We have to flush the work queue and remove a possible SNSS request
- * from the dasd queue.
- */
-static void
-dasd_eer_destroy(struct dasd_device *device, struct dasd_eer_private *eer)
-{
-        flush_workqueue(dasd_eer_workqueue);
-        dasd_eer_dequeue_SNSS_request(device, eer);
-        dasd_kfree_request(eer->cqr, device);
-        kfree(eer);
-};
-
-/*
- * enable the extended error reporting for a particular device
- */
-static int
-dasd_eer_enable_on_device(struct dasd_device *device)
-{
-        void *eer;
-        if (!device)
-                return -ENODEV;
-        if (device->eer)
-                return 0;
-        if (!try_module_get(THIS_MODULE)) {
-                return -EINVAL;
-        }
-        eer = (void *)dasd_eer_probe(device);
-        if (IS_ERR(eer)) {
-                module_put(THIS_MODULE);
-                return PTR_ERR(eer);
-        }
-        device->eer = eer;
-        return 0;
-}
-
-/*
- * enable the extended error reporting for a particular device
- */
-static int
-dasd_eer_disable_on_device(struct dasd_device *device)
-{
-        struct dasd_eer_private *eer = device->eer;
-
-        if (!device)
-                return -ENODEV;
-        if (!device->eer)
-                return 0;
-        device->eer = NULL;
-        dasd_eer_destroy(device,eer);
-        module_put(THIS_MODULE);
-
-        return 0;
-}
-
-/*
- * Set extended error reporting (eer)
- * Note: This will be registered as a DASD ioctl, to be called on DASD devices.
- */
-static int
-dasd_ioctl_set_eer(struct block_device *bdev, int no, long args)
-{
-        struct dasd_device *device;
-        int intval;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-        if (bdev != bdev->bd_contains)
-                /* Error-reporting is not allowed for partitions */
-                return -EINVAL;
-        if (get_user(intval, (int __user *) args))
-                return -EFAULT;
-        device =  bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
-        intval = (intval != 0);
-        DEV_MESSAGE (KERN_DEBUG, device,
-                     "set eer on device to %d", intval);
-        if (intval)
-                return dasd_eer_enable_on_device(device);
-        else
-                return dasd_eer_disable_on_device(device);
-}
-
-/*
- * Get value of extended error reporting.
- * Note: This will be registered as a DASD ioctl, to be called on DASD devices.
- */
-static int
-dasd_ioctl_get_eer(struct block_device *bdev, int no, long args)
-{
-        struct dasd_device *device;
-
-        device =  bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-        return put_user((device->eer != NULL), (int __user *) args);
-}
-
-/*
- * The following function can be used for those triggers that have
- * all necessary data available when the function is called.
- * If the parameter cqr is not NULL, the chain of requests will be searched
- * for valid sense data, and all valid sense data sets will be added to
- * the triggers data.
- */
-static int
-dasd_eer_write_standard_trigger(int trigger, struct dasd_device *device,
-                                struct dasd_ccw_req *cqr)
-{
-        struct dasd_ccw_req *temp_cqr;
-        int data_size;
-        struct timeval tv;
-        struct dasd_eer_header header;
-        unsigned long flags;
-        struct eerbuffer *eerb;
-
-        /* go through cqr chain and count the valid sense data sets */
-        temp_cqr = cqr;
-        data_size = 0;
-        while (temp_cqr) {
-                if (temp_cqr->irb.esw.esw0.erw.cons)
-                        data_size += 32;
-                temp_cqr = temp_cqr->refers;
-        }
-
-        header.total_size = sizeof(header) + data_size + 4; /* "EOR" */
-        header.trigger = trigger;
-        do_gettimeofday(&tv);
-        header.tv_sec = tv.tv_sec;
-        header.tv_usec = tv.tv_usec;
-        strncpy(header.busid, device->cdev->dev.bus_id, DASD_EER_BUSID_SIZE);
-
-        spin_lock_irqsave(&bufferlock, flags);
-        list_for_each_entry(eerb, &bufferlist, list) {
-                dasd_eer_start_record(eerb, header.total_size);
-                dasd_eer_write_buffer(eerb, sizeof(header), (char*)(&header));
-                temp_cqr = cqr;
-                while (temp_cqr) {
-                        if (temp_cqr->irb.esw.esw0.erw.cons)
-                                dasd_eer_write_buffer(eerb, 32, cqr->irb.ecw);
-                        temp_cqr = temp_cqr->refers;
-                }
-                dasd_eer_write_buffer(eerb, 4,"EOR");
-        }
-        spin_unlock_irqrestore(&bufferlock, flags);
-
-        wake_up_interruptible(&dasd_eer_read_wait_queue);
-
-        return 0;
-}
-
-/*
- * This function writes a DASD_EER_STATECHANGE trigger.
- */
-static void
-dasd_eer_write_SNSS_trigger(struct dasd_device *device,
-                            struct dasd_ccw_req *cqr)
-{
-        int data_size;
-        int snss_rc;
-        struct timeval tv;
-        struct dasd_eer_header header;
-        unsigned long flags;
-        struct eerbuffer *eerb;
-
-        snss_rc = (cqr->status == DASD_CQR_FAILED) ? -EIO : 0;
-        if (snss_rc)
-                data_size = 0;
-        else
-                data_size = SNSS_DATA_SIZE;
-
-        header.total_size = sizeof(header) + data_size + 4; /* "EOR" */
-        header.trigger = DASD_EER_STATECHANGE;
-        do_gettimeofday(&tv);
-        header.tv_sec = tv.tv_sec;
-        header.tv_usec = tv.tv_usec;
-        strncpy(header.busid, device->cdev->dev.bus_id, DASD_EER_BUSID_SIZE);
-
-        spin_lock_irqsave(&bufferlock, flags);
-        list_for_each_entry(eerb, &bufferlist, list) {
-                dasd_eer_start_record(eerb, header.total_size);
-                dasd_eer_write_buffer(eerb, sizeof(header),(char*)(&header));
-                if (!snss_rc)
-                        dasd_eer_write_buffer(eerb, SNSS_DATA_SIZE, cqr->data);
-                dasd_eer_write_buffer(eerb, 4,"EOR");
-        }
-        spin_unlock_irqrestore(&bufferlock, flags);
-
-        wake_up_interruptible(&dasd_eer_read_wait_queue);
-}
-
-/*
- * callback function for use with SNSS request
- */
-static void
-dasd_eer_SNSS_cb(struct dasd_ccw_req *cqr, void *data)
-{
-        struct dasd_device *device;
-        struct dasd_eer_private *private;
-        unsigned long irqflags;
-
-        device = (struct dasd_device *)data;
-        private = (struct dasd_eer_private *)device->eer;
-        dasd_eer_write_SNSS_trigger(device, cqr);
-        spin_lock_irqsave(&snsslock, irqflags);
-        if(!test_and_clear_bit(SNSS_REQUESTED, &private->flags)) {
-                clear_bit(CQR_IN_USE, &private->flags);
-                spin_unlock_irqrestore(&snsslock, irqflags);
-                return;
-        };
-        clear_bit(CQR_IN_USE, &private->flags);
-        spin_unlock_irqrestore(&snsslock, irqflags);
-        dasd_eer_sense_subsystem_status(device);
-        return;
-}
-
-/*
- * clean a used cqr before using it again
- */
-static void
-dasd_eer_clean_SNSS_request(struct dasd_ccw_req *cqr)
-{
-        struct ccw1 *cpaddr = cqr->cpaddr;
-        void *data = cqr->data;
-
-        memset(cqr, 0, sizeof(struct dasd_ccw_req));
-        memset(cpaddr, 0, sizeof(struct ccw1));
-        memset(data, 0, SNSS_DATA_SIZE);
-        cqr->cpaddr = cpaddr;
-        cqr->data = data;
-        strncpy((char *) &cqr->magic, "ECKD", 4);
-        ASCEBC((char *) &cqr->magic, 4);
-        set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
-}
-
-/*
- * build and start an SNSS request
- * This function is called from a work queue so we have to
- * pass the dasd_device pointer as a void pointer.
- */
-static void
-dasd_eer_sense_subsystem_status(void *data)
-{
-        struct dasd_device *device;
-        struct dasd_eer_private *private;
-        struct dasd_ccw_req *cqr;
-        struct ccw1 *ccw;
-        unsigned long irqflags;
-
-        device = (struct dasd_device *)data;
-        private = (struct dasd_eer_private *)device->eer;
-        if (!private) /* device not eer enabled any more */
-                return;
-        cqr = private->cqr;
-        spin_lock_irqsave(&snsslock, irqflags);
-        if(test_and_set_bit(CQR_IN_USE, &private->flags)) {
-                set_bit(SNSS_REQUESTED, &private->flags);
-                spin_unlock_irqrestore(&snsslock, irqflags);
-                return;
-        };
-        spin_unlock_irqrestore(&snsslock, irqflags);
-        dasd_eer_clean_SNSS_request(cqr);
-        cqr->device = device;
-        cqr->retries = 255;
-        cqr->expires = 10 * HZ;
-
-        ccw = cqr->cpaddr;
-        ccw->cmd_code = DASD_ECKD_CCW_SNSS;
-        ccw->count = SNSS_DATA_SIZE;
-        ccw->flags = 0;
-        ccw->cda = (__u32)(addr_t)cqr->data;
-
-        cqr->buildclk = get_clock();
-        cqr->status = DASD_CQR_FILLED;
-        cqr->callback = dasd_eer_SNSS_cb;
-        cqr->callback_data = (void *)device;
-        dasd_add_request_head(cqr);
-
-        return;
-}
-
-/*
- * This function is called for all triggers. It calls the appropriate
- * function that writes the actual trigger records.
- */
-static int
-dasd_eer_write_trigger(struct dasd_eer_trigger *trigger)
-{
-        int rc;
-        struct dasd_eer_private *private = trigger->device->eer;
-
-        switch (trigger->id) {
-        case DASD_EER_FATALERROR:
-        case DASD_EER_PPRCSUSPEND:
-                rc = dasd_eer_write_standard_trigger(
-                        trigger->id, trigger->device, trigger->cqr);
-                break;
-        case DASD_EER_NOPATH:
-                rc = dasd_eer_write_standard_trigger(
-                        trigger->id, trigger->device, NULL);
-                break;
-        case DASD_EER_STATECHANGE:
-                if (queue_work(dasd_eer_workqueue, &private->worker)) {
-                        rc=0;
-                } else {
-                        /* If the work_struct was already queued, it can't
-                         * be queued again. But this is OK since we don't
-                         * need to have it queued twice.
-                         */
-                        rc = -EBUSY;
-                }
-                break;
-        default: /* unknown trigger, so we write it without any sense data */
-                rc = dasd_eer_write_standard_trigger(
-                        trigger->id, trigger->device, NULL);
-                break;
-        }
-        return rc;
-}
-
-/*
- * This function is registered with the dasd device driver and gets called
- * for all dasd eer notifications.
- */
-static int dasd_eer_notify(struct notifier_block *self,
-                            unsigned long action, void *data)
-{
-        switch (action) {
-        case DASD_EER_DISABLE:
-                dasd_eer_disable_on_device((struct dasd_device *)data);
-                break;
-        case DASD_EER_TRIGGER:
-                dasd_eer_write_trigger((struct dasd_eer_trigger *)data);
-                break;
-        }
-        return NOTIFY_OK;
-}
-
-
-/*****************************************************************************/
-/*      the device operations                                                */
-/*****************************************************************************/
-
-/*
- * On the one side we need a lock to access our internal buffer, on the
- * other side a copy_to_user can sleep. So we need to copy the data we have
- * to transfer in a readbuffer, which is protected by the readbuffer_mutex.
- */
-static char readbuffer[PAGE_SIZE];
-DECLARE_MUTEX(readbuffer_mutex);
-
-
-static int
-dasd_eer_open(struct inode *inp, struct file *filp)
-{
-        struct eerbuffer *eerb;
-        unsigned long flags;
-
-        eerb = kmalloc(sizeof(struct eerbuffer), GFP_KERNEL);
-        eerb->head = 0;
-        eerb->tail = 0;
-        eerb->residual = 0;
-        eerb->buffer_page_count = 1;
-        eerb->buffersize = eerb->buffer_page_count * PAGE_SIZE;
-        eerb->buffer = kmalloc(eerb->buffer_page_count*sizeof(char*),
-                               GFP_KERNEL);
-        if (!eerb->buffer)
-                return -ENOMEM;
-        if (dasd_eer_allocate_buffer_pages(eerb->buffer,
-                                           eerb->buffer_page_count)) {
-                kfree(eerb->buffer);
-                return -ENOMEM;
-        }
-        filp->private_data = eerb;
-        spin_lock_irqsave(&bufferlock, flags);
-        list_add(&eerb->list, &bufferlist);
-        spin_unlock_irqrestore(&bufferlock, flags);
-
-        return nonseekable_open(inp,filp);
-}
-
-static int
-dasd_eer_close(struct inode *inp, struct file *filp)
-{
-        struct eerbuffer *eerb;
-        unsigned long flags;
-
-        eerb = (struct eerbuffer *)filp->private_data;
-        spin_lock_irqsave(&bufferlock, flags);
-        list_del(&eerb->list);
-        spin_unlock_irqrestore(&bufferlock, flags);
-        dasd_eer_free_buffer_pages(eerb->buffer, eerb->buffer_page_count);
-        kfree(eerb->buffer);
-        kfree(eerb);
-
-        return 0;
-}
-
-static long
-dasd_eer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
-        int intval;
-        struct eerbuffer *eerb;
-
-        eerb = (struct eerbuffer *)filp->private_data;
-        switch (cmd) {
-        case DASD_EER_PURGE:
-                dasd_eer_purge_buffer(eerb);
-                return 0;
-        case DASD_EER_SETBUFSIZE:
-                if (get_user(intval, (int __user *)arg))
-                        return -EFAULT;
-                return dasd_eer_resize_buffer(eerb, intval);
-        default:
-                return -ENOIOCTLCMD;
-        }
-}
-
-static ssize_t
-dasd_eer_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
-{
-        int tc,rc;
-        int tailcount,effective_count;
-        unsigned long flags;
-        struct eerbuffer *eerb;
-
-        eerb = (struct eerbuffer *)filp->private_data;
-        if(down_interruptible(&readbuffer_mutex))
-                return -ERESTARTSYS;
-
-        spin_lock_irqsave(&bufferlock, flags);
-
-        if (eerb->residual < 0) { /* the remainder of this record */
-                                  /* has been deleted             */
-                eerb->residual = 0;
-                spin_unlock_irqrestore(&bufferlock, flags);
-                up(&readbuffer_mutex);
-                return -EIO;
-        } else if (eerb->residual > 0) {
-                /* OK we still have a second half of a record to deliver */
-                effective_count = min(eerb->residual, (int)count);
-                eerb->residual -= effective_count;
-        } else {
-                tc = 0;
-                while (!tc) {
-                        tc = dasd_eer_read_buffer(eerb,
-                                sizeof(tailcount), (char*)(&tailcount));
-                        if (!tc) {
-                                /* no data available */
-                                spin_unlock_irqrestore(&bufferlock, flags);
-                                up(&readbuffer_mutex);
-                                if (filp->f_flags & O_NONBLOCK)
-                                        return -EAGAIN;
-                                rc = wait_event_interruptible(
-                                        dasd_eer_read_wait_queue,
-                                        eerb->head != eerb->tail);
-                                if (rc) {
-                                        return rc;
-                                }
-                                if(down_interruptible(&readbuffer_mutex))
-                                        return -ERESTARTSYS;
-                                spin_lock_irqsave(&bufferlock, flags);
-                        }
-                }
-                WARN_ON(tc != sizeof(tailcount));
-                effective_count = min(tailcount,(int)count);
-                eerb->residual = tailcount - effective_count;
-        }
-
-        tc = dasd_eer_read_buffer(eerb, effective_count, readbuffer);
-        WARN_ON(tc != effective_count);
-
-        spin_unlock_irqrestore(&bufferlock, flags);
-
-        if (copy_to_user(buf, readbuffer, effective_count)) {
-                up(&readbuffer_mutex);
-                return -EFAULT;
-        }
-
-        up(&readbuffer_mutex);
-        return effective_count;
-}
-
-static unsigned int
-dasd_eer_poll (struct file *filp, poll_table *ptable)
-{
-        unsigned int mask;
-        unsigned long flags;
-        struct eerbuffer *eerb;
-
-        eerb = (struct eerbuffer *)filp->private_data;
-        poll_wait(filp, &dasd_eer_read_wait_queue, ptable);
-        spin_lock_irqsave(&bufferlock, flags);
-        if (eerb->head != eerb->tail)
-                mask = POLLIN | POLLRDNORM ;
-        else
-                mask = 0;
-        spin_unlock_irqrestore(&bufferlock, flags);
-        return mask;
-}
-
-static struct file_operations dasd_eer_fops = {
-        .open           = &dasd_eer_open,
-        .release        = &dasd_eer_close,
-        .unlocked_ioctl = &dasd_eer_ioctl,
-        .compat_ioctl   = &dasd_eer_ioctl,
-        .read           = &dasd_eer_read,
-        .poll           = &dasd_eer_poll,
-        .owner          = THIS_MODULE,
-};
-
-static struct miscdevice dasd_eer_dev = {
-        .minor      = MISC_DYNAMIC_MINOR,
-        .name       = "dasd_eer",
-        .fops       = &dasd_eer_fops,
-};
-
-
-/*****************************************************************************/
-/*      Init and exit                                                        */
-/*****************************************************************************/
-
-static int
-__init dasd_eer_init(void)
-{
-        int rc;
-
-        dasd_eer_workqueue = create_singlethread_workqueue("dasd_eer");
-        if (!dasd_eer_workqueue) {
-                MESSAGE(KERN_ERR , "%s", "dasd_eer_init could not "
-                       "create workqueue \n");
-                rc = -ENOMEM;
-                goto out;
-        }
-
-        rc = dasd_register_eer_notifier(&dasd_eer_nb);
-        if (rc) {
-                MESSAGE(KERN_ERR, "%s", "dasd_eer_init could not "
-                       "register error reporting");
-                goto queue;
-        }
-
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDEERSET, dasd_ioctl_set_eer);
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDEERGET, dasd_ioctl_get_eer);
-
-        /* we don't need our own character device,
-         * so we just register as misc device */
-        rc = misc_register(&dasd_eer_dev);
-        if (rc) {
-                MESSAGE(KERN_ERR, "%s", "dasd_eer_init could not "
-                       "register misc device");
-                goto unregister;
-        }
-
-        return 0;
-
-unregister:
-        dasd_unregister_eer_notifier(&dasd_eer_nb);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERSET,
-                                 dasd_ioctl_set_eer);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERGET,
-                                 dasd_ioctl_get_eer);
-queue:
-        destroy_workqueue(dasd_eer_workqueue);
-out:
-        return rc;
-
-}
-module_init(dasd_eer_init);
-
-static void
-__exit dasd_eer_exit(void)
-{
-        dasd_unregister_eer_notifier(&dasd_eer_nb);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERSET,
-                                 dasd_ioctl_set_eer);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERGET,
-                                 dasd_ioctl_get_eer);
-        destroy_workqueue(dasd_eer_workqueue);
-
-        WARN_ON(misc_deregister(&dasd_eer_dev) != 0);
-}
-module_exit(dasd_eer_exit);
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index d1b08fa13fd2..0592354cc604 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -275,34 +275,6 @@ struct dasd_discipline {
 
 extern struct dasd_discipline *dasd_diag_discipline_pointer;
 
-
-/*
- * Notification numbers for extended error reporting notifications:
- * The DASD_EER_DISABLE notification is sent before a dasd_device (and it's
- * eer pointer) is freed. The error reporting module needs to do all necessary
- * cleanup steps.
- * The DASD_EER_TRIGGER notification sends the actual error reports (triggers).
- */
-#define DASD_EER_DISABLE 0
-#define DASD_EER_TRIGGER 1
-
-/* Trigger IDs for extended error reporting DASD_EER_TRIGGER notification */
-#define DASD_EER_FATALERROR  1
-#define DASD_EER_NOPATH      2
-#define DASD_EER_STATECHANGE 3
-#define DASD_EER_PPRCSUSPEND 4
-
-/*
- * The dasd_eer_trigger structure contains all data that we need to send
- * along with an DASD_EER_TRIGGER notification.
- */
-struct dasd_eer_trigger {
-        unsigned int id;
-        struct dasd_device *device;
-        struct dasd_ccw_req *cqr;
-};
-
-
 struct dasd_device {
         /* Block device stuff. */
         struct gendisk *gdp;
@@ -316,11 +288,9 @@ struct dasd_device {
         unsigned long flags;            /* per device flags */
         unsigned short features;        /* copy of devmap-features (read-only!) */
 
-        /* extended error reporting stuff (eer) */
-        void *eer;
-
         /* Device discipline stuff. */
         struct dasd_discipline *discipline;
+        struct dasd_discipline *base_discipline;
         char *private;
 
         /* Device state and target state. */
@@ -519,12 +489,6 @@ int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *);
 int dasd_generic_set_offline (struct ccw_device *cdev);
 int dasd_generic_notify(struct ccw_device *, int);
 void dasd_generic_auto_online (struct ccw_driver *);
-int dasd_register_eer_notifier(struct notifier_block *);
-int dasd_unregister_eer_notifier(struct notifier_block *);
-void dasd_write_eer_trigger(unsigned int , struct dasd_device *,
-                        struct dasd_ccw_req *);
-
-
 
 /* externals in dasd_devmap.c */
 extern int dasd_max_devindex;
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 062fb100d94c..afc4e88551ad 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -359,7 +359,7 @@ ccw_device_set_online(struct ccw_device *cdev)
         else 
                 pr_debug("ccw_device_offline returned %d, device %s\n",
                          ret, cdev->dev.bus_id);
-        return (ret = 0) ? -ENODEV : ret;
+        return (ret == 0) ? -ENODEV : ret;
 }
 
 static ssize_t
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index d2a5b04d7cba..85b1020a1fcc 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -405,7 +405,7 @@ __ccw_device_disband_start(struct ccw_device *cdev)
                 cdev->private->iretry = 5;
                 cdev->private->imask >>= 1;
         }
-        ccw_device_verify_done(cdev, (sch->lpm != 0) ? 0 : -ENODEV);
+        ccw_device_disband_done(cdev, (sch->lpm != 0) ? 0 : -ENODEV);
 }
 
 /*
diff --git a/drivers/s390/cio/device_status.c b/drivers/s390/cio/device_status.c
index dad4dd9887c9..6c762b43f921 100644
--- a/drivers/s390/cio/device_status.c
+++ b/drivers/s390/cio/device_status.c
@@ -317,7 +317,6 @@ ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb)
         /*
          * We have ending status but no sense information. Do a basic sense.
          */
-        sch = to_subchannel(cdev->dev.parent);
         sch->sense_ccw.cmd_code = CCW_CMD_BASIC_SENSE;
         sch->sense_ccw.cda = (__u32) __pa(cdev->private->irb.ecw);
         sch->sense_ccw.count = SENSE_MAX_COUNT;
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index 45ce032772f4..9ed37dc9a1b0 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -165,8 +165,13 @@ qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
         q_no = q->q_no;
         if(!q->is_input_q)
                 q_no += irq->no_input_qs;
+again:
         ccq = do_eqbs(irq->sch_token, state, q_no, start, cnt);
         rc = qdio_check_ccq(q, ccq);
+        if (rc == 1) {
+                QDIO_DBF_TEXT5(1,trace,"eqAGAIN");
+                goto again;
+        }
         if (rc < 0) {
                 QDIO_DBF_TEXT2(1,trace,"eqberr");
                 sprintf(dbf_text,"%2x,%2x,%d,%d",tmp_cnt, *cnt, ccq, q_no);
@@ -195,8 +200,13 @@ qdio_do_sqbs(struct qdio_q *q, unsigned char state,
         q_no = q->q_no;
         if(!q->is_input_q)
                 q_no += irq->no_input_qs;
+again:
         ccq = do_sqbs(irq->sch_token, state, q_no, start, cnt);
         rc = qdio_check_ccq(q, ccq);
+        if (rc == 1) {
+                QDIO_DBF_TEXT5(1,trace,"sqAGAIN");
+                goto again;
+        }
         if (rc < 0) {
                 QDIO_DBF_TEXT3(1,trace,"sqberr");
                 sprintf(dbf_text,"%2x,%2x,%d,%d",tmp_cnt,*cnt,ccq,q_no);
@@ -1187,8 +1197,7 @@ tiqdio_is_inbound_q_done(struct qdio_q *q)
 
         if (!no_used)
                 return 1;
-
-        if (!q->siga_sync)
+        if (!q->siga_sync && !irq->is_qebsm)
                 /* we'll check for more primed buffers in qeth_stop_polling */
                 return 0;
         if (irq->is_qebsm) {
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index 6229ba4995ad..9cf88d7201d3 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -98,9 +98,9 @@ lcs_register_debug_facility(void)
                 return -ENOMEM;
         }
         debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
-        debug_set_level(lcs_dbf_setup, 4);
+        debug_set_level(lcs_dbf_setup, 2);
         debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
-        debug_set_level(lcs_dbf_trace, 4);
+        debug_set_level(lcs_dbf_trace, 2);
         return 0;
 }
 
@@ -1292,9 +1292,8 @@ lcs_set_multicast_list(struct net_device *dev)
         LCS_DBF_TEXT(4, trace, "setmulti");
         card = (struct lcs_card *) dev->priv;
 
-        if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD)) {
+        if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD)) 
                 schedule_work(&card->kernel_thread_starter);
-        }
 }
 
 #endif /* CONFIG_IP_MULTICAST */
@@ -1459,6 +1458,8 @@ lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
         lcs_release_buffer(channel, buffer);
         card = (struct lcs_card *)
                 ((char *) channel - offsetof(struct lcs_card, write));
+        if (netif_queue_stopped(card->dev))
+                netif_wake_queue(card->dev);
         spin_lock(&card->lock);
         card->tx_emitted--;
         if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
@@ -1478,6 +1479,7 @@ __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
                  struct net_device *dev)
 {
         struct lcs_header *header;
+        int rc = 0;
 
         LCS_DBF_TEXT(5, trace, "hardxmit");
         if (skb == NULL) {
@@ -1492,10 +1494,8 @@ __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
                 card->stats.tx_carrier_errors++;
                 return 0;
         }
-        if (netif_queue_stopped(dev) ) {
-                card->stats.tx_dropped++;
-                return -EBUSY;
-        }
+        netif_stop_queue(card->dev);
+        spin_lock(&card->lock);
         if (card->tx_buffer != NULL &&
             card->tx_buffer->count + sizeof(struct lcs_header) +
             skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
@@ -1506,7 +1506,8 @@ __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
                 card->tx_buffer = lcs_get_buffer(&card->write);
                 if (card->tx_buffer == NULL) {
                         card->stats.tx_dropped++;
-                        return -EBUSY;
+                        rc = -EBUSY;
+                        goto out;
                 }
                 card->tx_buffer->callback = lcs_txbuffer_cb;
                 card->tx_buffer->count = 0;
@@ -1518,13 +1519,18 @@ __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
         header->type = card->lan_type;
         header->slot = card->portno;
         memcpy(header + 1, skb->data, skb->len);
+        spin_unlock(&card->lock);
         card->stats.tx_bytes += skb->len;
         card->stats.tx_packets++;
         dev_kfree_skb(skb);
-        if (card->tx_emitted <= 0)
+        netif_wake_queue(card->dev);
+        spin_lock(&card->lock);
+        if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
                 /* If this is the first tx buffer emit it immediately. */
                 __lcs_emit_txbuffer(card);
-        return 0;
+out:
+        spin_unlock(&card->lock);
+        return rc;
 }
 
 static int
@@ -1535,9 +1541,7 @@ lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         LCS_DBF_TEXT(5, trace, "pktxmit");
         card = (struct lcs_card *) dev->priv;
-        spin_lock(&card->lock);
         rc = __lcs_start_xmit(card, skb, dev);
-        spin_unlock(&card->lock);
         return rc;
 }
 
@@ -2319,7 +2323,6 @@ __init lcs_init_module(void)
                 PRINT_ERR("Initialization failed\n");
                 return rc;
         }
-
         return 0;
 }
 
diff --git a/drivers/s390/net/lcs.h b/drivers/s390/net/lcs.h
index 08e60ad43916..2fad5e40c2e4 100644
--- a/drivers/s390/net/lcs.h
+++ b/drivers/s390/net/lcs.h
@@ -95,7 +95,7 @@ do {                                       \
  */
 #define LCS_ILLEGAL_OFFSET              0xffff
 #define LCS_IOBUFFERSIZE                0x5000
-#define LCS_NUM_BUFFS                   8       /* needs to be power of 2 */
+#define LCS_NUM_BUFFS                   32      /* needs to be power of 2 */
 #define LCS_MAC_LENGTH                  6
 #define LCS_INVALID_PORT_NO             -1
 #define LCS_LANCMD_TIMEOUT_DEFAULT      5
diff --git a/drivers/s390/net/qeth.h b/drivers/s390/net/qeth.h
index 9a064d4727ad..4df0fcd7b10b 100644
--- a/drivers/s390/net/qeth.h
+++ b/drivers/s390/net/qeth.h
@@ -1076,16 +1076,6 @@ qeth_get_qdio_q_format(struct qeth_card *card)
 }
 
 static inline int
-qeth_isdigit(char * buf)
-{
-        while (*buf) {
-                if (!isdigit(*buf++))
-                        return 0;
-        }
-        return 1;
-}
-
-static inline int
 qeth_isxdigit(char * buf)
 {
         while (*buf) {
@@ -1104,33 +1094,17 @@ qeth_ipaddr4_to_string(const __u8 *addr, char *buf)
 static inline int
 qeth_string_to_ipaddr4(const char *buf, __u8 *addr)
 {
-        const char *start, *end;
-        char abuf[4];
-        char *tmp;
-        int len;
-        int i;
-
-        start = buf;
-        for (i = 0; i < 4; i++) {
-                if (i == 3) {
-                        end = strchr(start,0xa);
-                        if (end)
-                                len = end - start;
-                        else            
-                                len = strlen(start);
-                }
-                else {
-                        end = strchr(start, '.');
-                        len = end - start;
-                }
-                if ((len <= 0) || (len > 3))
-                        return -EINVAL;
-                memset(abuf, 0, 4);
-                strncpy(abuf, start, len);
-                if (!qeth_isdigit(abuf))
+        int count = 0, rc = 0;
+        int in[4];
+
+        rc = sscanf(buf, "%d.%d.%d.%d%n", 
+                    &in[0], &in[1], &in[2], &in[3], &count);
+        if (rc != 4  || count) 
+                return -EINVAL;
+        for (count = 0; count < 4; count++) {
+                if (in[count] > 255)
                         return -EINVAL;
-                addr[i] = simple_strtoul(abuf, &tmp, 10);
-                start = end + 1;
+                addr[count] = in[count];
         }
         return 0;
 }
@@ -1149,36 +1123,44 @@ qeth_ipaddr6_to_string(const __u8 *addr, char *buf)
 static inline int
 qeth_string_to_ipaddr6(const char *buf, __u8 *addr)
 {
-        const char *start, *end;
-        u16 *tmp_addr;
-        char abuf[5];
-        char *tmp;
-        int len;
-        int i;
-
-        tmp_addr = (u16 *)addr;
-        start = buf;
-        for (i = 0; i < 8; i++) {
-                if (i == 7) {
-                        end = strchr(start,0xa);
-                        if (end)
-                                len = end - start;
-                        else
-                                len = strlen(start);
-                }
-                else {
-                        end = strchr(start, ':');
-                        len = end - start;
+        char *end, *start;
+        __u16 *in;
+        char num[5];
+        int num2, cnt, out, found, save_cnt;
+        unsigned short in_tmp[8] = {0, };
+
+        cnt = out = found = save_cnt = num2 = 0;
+        end = start = (char *) buf;
+        in = (__u16 *) addr;    
+        memset(in, 0, 16);
+        while (end) {
+                end = strchr(end,':');
+                if (end == NULL) {
+                        end = (char *)buf + (strlen(buf));
+                        out = 1;
+                }
+                if ((end - start)) { 
+                        memset(num, 0, 5);
+                        memcpy(num, start, end - start);
+                        if (!qeth_isxdigit(num))
+                                return -EINVAL;
+                        sscanf(start, "%x", &num2);
+                        if (found)
+                                in_tmp[save_cnt++] = num2;
+                        else
+                                in[cnt++] = num2;
+                        if (out)
+                                break;
+                } else {
+                        if (found)
+                                return -EINVAL;
+                        found = 1;
                 }
-                if ((len <= 0) || (len > 4))
-                        return -EINVAL;
-                memset(abuf, 0, 5);
-                strncpy(abuf, start, len);
-                if (!qeth_isxdigit(abuf))
-                        return -EINVAL;
-                tmp_addr[i] = simple_strtoul(abuf, &tmp, 16);
-                start = end + 1;
-        }
+                start = ++end;
+        }
+        cnt = 7;
+        while (save_cnt)
+                in[cnt--] = in_tmp[--save_cnt];
         return 0;
 }
 
diff --git a/drivers/s390/net/qeth_eddp.c b/drivers/s390/net/qeth_eddp.c
index b02313127780..82cb4af2f0e7 100644
--- a/drivers/s390/net/qeth_eddp.c
+++ b/drivers/s390/net/qeth_eddp.c
@@ -59,8 +59,7 @@ qeth_eddp_free_context(struct qeth_eddp_context *ctx)
         for (i = 0; i < ctx->num_pages; ++i)
                 free_page((unsigned long)ctx->pages[i]);
         kfree(ctx->pages);
-        if (ctx->elements != NULL)
-                kfree(ctx->elements);
+        kfree(ctx->elements);
         kfree(ctx);
 }
 
@@ -413,6 +412,13 @@ __qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
         
         QETH_DBF_TEXT(trace, 5, "eddpftcp");
         eddp->skb_offset = sizeof(struct qeth_hdr) + eddp->nhl + eddp->thl;
+       if (eddp->qh.hdr.l2.id == QETH_HEADER_TYPE_LAYER2) {
+               eddp->skb_offset += sizeof(struct ethhdr);
+#ifdef CONFIG_QETH_VLAN
+               if (eddp->mac.h_proto == __constant_htons(ETH_P_8021Q))
+                       eddp->skb_offset += VLAN_HLEN;
+#endif /* CONFIG_QETH_VLAN */
+       }
         tcph = eddp->skb->h.th;
         while (eddp->skb_offset < eddp->skb->len) {
                 data_len = min((int)skb_shinfo(eddp->skb)->tso_size,
@@ -483,6 +489,7 @@ qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
                 return -ENOMEM;
         }
         if (qhdr->hdr.l2.id == QETH_HEADER_TYPE_LAYER2) {
+                skb->mac.raw = (skb->data) + sizeof(struct qeth_hdr);
                 memcpy(&eddp->mac, eth_hdr(skb), ETH_HLEN);
 #ifdef CONFIG_QETH_VLAN
                 if (eddp->mac.h_proto == __constant_htons(ETH_P_8021Q)) {
diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index 410abeada6c4..dba7f7f02e79 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -516,7 +516,8 @@ __qeth_set_offline(struct ccwgroup_device *cgdev, int recovery_mode)
         QETH_DBF_TEXT(setup, 3, "setoffl");
         QETH_DBF_HEX(setup, 3, &card, sizeof(void *));
         
-        netif_carrier_off(card->dev);
+        if (card->dev && netif_carrier_ok(card->dev))
+                netif_carrier_off(card->dev);
         recover_flag = card->state;
         if (qeth_stop_card(card, recovery_mode) == -ERESTARTSYS){
                 PRINT_WARN("Stopping card %s interrupted by user!\n",
@@ -1679,6 +1680,7 @@ qeth_cmd_timeout(unsigned long data)
         spin_unlock_irqrestore(&reply->card->lock, flags);
 }
 
+
 static struct qeth_ipa_cmd *
 qeth_check_ipa_data(struct qeth_card *card, struct qeth_cmd_buffer *iob)
 {
@@ -1699,7 +1701,8 @@ qeth_check_ipa_data(struct qeth_card *card, struct qeth_cmd_buffer *iob)
                                            QETH_CARD_IFNAME(card),
                                            card->info.chpid);
                                 card->lan_online = 0;
-                                netif_carrier_off(card->dev);
+                                if (card->dev && netif_carrier_ok(card->dev))
+                                        netif_carrier_off(card->dev);
                                 return NULL;
                         case IPA_CMD_STARTLAN:
                                 PRINT_INFO("Link reestablished on %s "
@@ -5562,7 +5565,7 @@ qeth_set_multicast_list(struct net_device *dev)
         if (card->info.type == QETH_CARD_TYPE_OSN)
                 return ;
          
-        QETH_DBF_TEXT(trace,3,"setmulti");
+        QETH_DBF_TEXT(trace, 3, "setmulti");
         qeth_delete_mc_addresses(card);
         if (card->options.layer2) {
                 qeth_layer2_add_multicast(card);
@@ -5579,7 +5582,6 @@ out:
                 return;
         if (qeth_set_thread_start_bit(card, QETH_SET_PROMISC_MODE_THREAD)==0)
                 schedule_work(&card->kernel_thread_starter);
-
 }
 
 static int
@@ -7452,6 +7454,7 @@ qeth_softsetup_card(struct qeth_card *card)
                 card->lan_online = 1;
         if (card->info.type==QETH_CARD_TYPE_OSN)
                 goto out;
+        qeth_set_large_send(card, card->options.large_send);
         if (card->options.layer2) {
                 card->dev->features |=
                         NETIF_F_HW_VLAN_FILTER |
@@ -7468,12 +7471,6 @@ qeth_softsetup_card(struct qeth_card *card)
 #endif
                 goto out;
         }
-        if ((card->options.large_send == QETH_LARGE_SEND_EDDP) ||
-            (card->options.large_send == QETH_LARGE_SEND_TSO))
-                card->dev->features |= NETIF_F_TSO | NETIF_F_SG;
-        else
-                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
-
         if ((rc = qeth_setadapter_parms(card)))
                 QETH_DBF_TEXT_(setup, 2, "2err%d", rc);
         if ((rc = qeth_start_ipassists(card)))
diff --git a/drivers/scsi/esp.c b/drivers/scsi/esp.c
index f6900538be90..87a8c3d2072c 100644
--- a/drivers/scsi/esp.c
+++ b/drivers/scsi/esp.c
@@ -2068,14 +2068,12 @@ static int esp_reset(struct scsi_cmnd *SCptr)
 {
         struct esp *esp = (struct esp *) SCptr->device->host->hostdata;
 
+        spin_lock_irq(esp->ehost->host_lock);
         (void) esp_do_resetbus(esp);
-
         spin_unlock_irq(esp->ehost->host_lock);
 
         wait_event(esp->reset_queue, (esp->resetting_bus == 0));
 
-        spin_lock_irq(esp->ehost->host_lock);
-
         return SUCCESS;
 }
 
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 46c4cdbaee86..5f1d7580218d 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -614,7 +614,7 @@ int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
         } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
                 /* Unable to use DMA due to host limitation */
                 tf->protocol = ATA_PROT_PIO;
-                index = dev->multi_count ? 0 : 4;
+                index = dev->multi_count ? 0 : 8;
         } else {
                 tf->protocol = ATA_PROT_DMA;
                 index = 16;
@@ -2514,7 +2514,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
         assert(sg != NULL);
 
         if (qc->flags & ATA_QCFLAG_SINGLE)
-                assert(qc->n_elem == 1);
+                assert(qc->n_elem <= 1);
 
         VPRINTK("unmapping %u sg elements\n", qc->n_elem);
 
@@ -2537,7 +2537,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
                         kunmap_atomic(addr, KM_IRQ0);
                 }
         } else {
-                if (sg_dma_len(&sg[0]) > 0)
+                if (qc->n_elem)
                         dma_unmap_single(ap->host_set->dev,
                                 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
                                 dir);
@@ -2570,7 +2570,7 @@ static void ata_fill_sg(struct ata_queued_cmd *qc)
         unsigned int idx;
 
         assert(qc->__sg != NULL);
-        assert(qc->n_elem > 0);
+        assert(qc->n_elem > 0 || qc->pad_len > 0);
 
         idx = 0;
         ata_for_each_sg(sg, qc) {
@@ -2715,6 +2715,7 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
         int dir = qc->dma_dir;
         struct scatterlist *sg = qc->__sg;
         dma_addr_t dma_address;
+        int trim_sg = 0;
 
         /* we must lengthen transfers to end on a 32-bit boundary */
         qc->pad_len = sg->length & 3;
@@ -2734,13 +2735,15 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
                 /* trim sg */
                 sg->length -= qc->pad_len;
+                if (sg->length == 0)
+                        trim_sg = 1;
 
                 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
                         sg->length, qc->pad_len);
         }
 
-        if (!sg->length) {
-                sg_dma_address(sg) = 0;
+        if (trim_sg) {
+                qc->n_elem--;
                 goto skip_map;
         }
 
@@ -2753,9 +2756,9 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
         }
 
         sg_dma_address(sg) = dma_address;
-skip_map:
         sg_dma_len(sg) = sg->length;
 
+skip_map:
         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
 
@@ -3357,11 +3360,12 @@ static void ata_pio_error(struct ata_port *ap)
 {
         struct ata_queued_cmd *qc;
 
-        printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
-
         qc = ata_qc_from_tag(ap, ap->active_tag);
         assert(qc != NULL);
 
+        if (qc->tf.command != ATA_CMD_PACKET)
+                printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
+
         /* make sure qc->err_mask is available to 
          * know what's wrong and recover
          */
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index 6fddf17a3b70..2770005324b4 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -997,6 +997,7 @@ static void mv_qc_prep(struct ata_queued_cmd *qc)
         case ATA_CMD_READ_EXT:
         case ATA_CMD_WRITE:
         case ATA_CMD_WRITE_EXT:
+        case ATA_CMD_WRITE_FUA_EXT:
                 mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
                 break;
 #ifdef LIBATA_NCQ               /* FIXME: remove this line when NCQ added */
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index de05e2883f9c..80480f0fb2b8 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -277,7 +277,7 @@ static unsigned int qs_fill_sg(struct ata_queued_cmd *qc)
         u8 *prd = pp->pkt + QS_CPB_BYTES;
 
         assert(qc->__sg != NULL);
-        assert(qc->n_elem > 0);
+        assert(qc->n_elem > 0 || qc->pad_len > 0);
 
         nelem = 0;
         ata_for_each_sg(sg, qc) {
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index 17f74d3c10e7..9face3c6aa21 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -49,11 +49,13 @@
 #define DRV_VERSION     "0.9"
 
 enum {
+        SIL_FLAG_RERR_ON_DMA_ACT = (1 << 29),
         SIL_FLAG_MOD15WRITE     = (1 << 30),
 
         sil_3112                = 0,
         sil_3112_m15w           = 1,
-        sil_3114                = 2,
+        sil_3512                = 2,
+        sil_3114                = 3,
 
         SIL_FIFO_R0             = 0x40,
         SIL_FIFO_W0             = 0x41,
@@ -90,7 +92,7 @@ static void sil_post_set_mode (struct ata_port *ap);
 static const struct pci_device_id sil_pci_tbl[] = {
         { 0x1095, 0x3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
         { 0x1095, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
-        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3512 },
         { 0x1095, 0x3114, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3114 },
         { 0x1002, 0x436e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
         { 0x1002, 0x4379, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
@@ -185,7 +187,8 @@ static const struct ata_port_info sil_port_info[] = {
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil_ops,
-        }, /* sil_3112_15w - keep it sync'd w/ sil_3112 */
+        },
+        /* sil_3112_15w - keep it sync'd w/ sil_3112 */
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
@@ -195,11 +198,24 @@ static const struct ata_port_info sil_port_info[] = {
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil_ops,
-        }, /* sil_3114 */
+        },
+        /* sil_3512 */
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO,
+                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
+                                  SIL_FLAG_RERR_ON_DMA_ACT,
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil_ops,
+        },
+        /* sil_3114 */
+        {
+                .sht            = &sil_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
+                                  SIL_FLAG_RERR_ON_DMA_ACT,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -216,12 +232,13 @@ static const struct {
         unsigned long scr;      /* SATA control register block */
         unsigned long sien;     /* SATA Interrupt Enable register */
         unsigned long xfer_mode;/* data transfer mode register */
+        unsigned long sfis_cfg; /* SATA FIS reception config register */
 } sil_port[] = {
         /* port 0 ... */
-        { 0x80, 0x8A, 0x00, 0x100, 0x148, 0xb4 },
-        { 0xC0, 0xCA, 0x08, 0x180, 0x1c8, 0xf4 },
-        { 0x280, 0x28A, 0x200, 0x300, 0x348, 0x2b4 },
-        { 0x2C0, 0x2CA, 0x208, 0x380, 0x3c8, 0x2f4 },
+        { 0x80, 0x8A, 0x00, 0x100, 0x148, 0xb4, 0x14c },
+        { 0xC0, 0xCA, 0x08, 0x180, 0x1c8, 0xf4, 0x1cc },
+        { 0x280, 0x28A, 0x200, 0x300, 0x348, 0x2b4, 0x34c },
+        { 0x2C0, 0x2CA, 0x208, 0x380, 0x3c8, 0x2f4, 0x3cc },
         /* ... port 3 */
 };
 
@@ -471,6 +488,23 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 dev_printk(KERN_WARNING, &pdev->dev,
                          "cache line size not set.  Driver may not function\n");
 
+        /* Apply R_ERR on DMA activate FIS errata workaround */
+        if (probe_ent->host_flags & SIL_FLAG_RERR_ON_DMA_ACT) {
+                int cnt;
+
+                for (i = 0, cnt = 0; i < probe_ent->n_ports; i++) {
+                        tmp = readl(mmio_base + sil_port[i].sfis_cfg);
+                        if ((tmp & 0x3) != 0x01)
+                                continue;
+                        if (!cnt)
+                                dev_printk(KERN_INFO, &pdev->dev,
+                                           "Applying R_ERR on DMA activate "
+                                           "FIS errata fix\n");
+                        writel(tmp & ~0x3, mmio_base + sil_port[i].sfis_cfg);
+                        cnt++;
+                }
+        }
+
         if (ent->driver_data == sil_3114) {
                 irq_mask = SIL_MASK_4PORT;
 
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 2e2c3b7acb0c..e484e8db6810 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -81,6 +81,19 @@
 /* Port stride */
 #define VSC_SATA_PORT_OFFSET            0x200
 
+/* Error interrupt status bit offsets */
+#define VSC_SATA_INT_ERROR_E_OFFSET     2
+#define VSC_SATA_INT_ERROR_P_OFFSET     4
+#define VSC_SATA_INT_ERROR_T_OFFSET     5
+#define VSC_SATA_INT_ERROR_M_OFFSET     1
+#define is_vsc_sata_int_err(port_idx, int_status) \
+         (int_status & ((1 << (VSC_SATA_INT_ERROR_E_OFFSET + (8 * port_idx))) | \
+                        (1 << (VSC_SATA_INT_ERROR_P_OFFSET + (8 * port_idx))) | \
+                        (1 << (VSC_SATA_INT_ERROR_T_OFFSET + (8 * port_idx))) | \
+                        (1 << (VSC_SATA_INT_ERROR_M_OFFSET + (8 * port_idx)))   \
+                       )\
+         )
+
 
 static u32 vsc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
@@ -201,13 +214,28 @@ static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance,
                         struct ata_port *ap;
 
                         ap = host_set->ports[i];
+
+                        if (is_vsc_sata_int_err(i, int_status)) {
+                                u32 err_status;
+                                printk(KERN_DEBUG "%s: ignoring interrupt(s)\n", __FUNCTION__);
+                                err_status = ap ? vsc_sata_scr_read(ap, SCR_ERROR) : 0;
+                                vsc_sata_scr_write(ap, SCR_ERROR, err_status);
+                                handled++;
+                        }
+
                         if (ap && !(ap->flags &
                                     (ATA_FLAG_PORT_DISABLED|ATA_FLAG_NOINTR))) {
                                 struct ata_queued_cmd *qc;
 
                                 qc = ata_qc_from_tag(ap, ap->active_tag);
-                                if (qc && (!(qc->tf.ctl & ATA_NIEN)))
+                                if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
                                         handled += ata_host_intr(ap, qc);
+                                } else {
+                                        printk(KERN_DEBUG "%s: ignoring interrupt(s)\n", __FUNCTION__);
+                                        ata_chk_status(ap);
+                                        handled++;
+                                }
+
                         }
                 }
         }
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 930db398d107..9d9872347f56 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -89,6 +89,11 @@
 #define SD_MAX_RETRIES          5
 #define SD_PASSTHROUGH_RETRIES  1
 
+/*
+ * Size of the initial data buffer for mode and read capacity data
+ */
+#define SD_BUF_SIZE             512
+
 static void scsi_disk_release(struct kref *kref);
 
 struct scsi_disk {
@@ -1239,7 +1244,7 @@ sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
 
 /*
  * read write protect setting, if possible - called only in sd_revalidate_disk()
- * called with buffer of length 512
+ * called with buffer of length SD_BUF_SIZE
  */
 static void
 sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
@@ -1297,7 +1302,7 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
 
 /*
  * sd_read_cache_type - called only from sd_revalidate_disk()
- * called with buffer of length 512
+ * called with buffer of length SD_BUF_SIZE
  */
 static void
 sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
@@ -1342,6 +1347,8 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
 
         /* Take headers and block descriptors into account */
         len += data.header_length + data.block_descriptor_length;
+        if (len > SD_BUF_SIZE)
+                goto bad_sense;
 
         /* Get the data */
         res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
@@ -1354,6 +1361,12 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
                 int ct = 0;
                 int offset = data.header_length + data.block_descriptor_length;
 
+                if (offset >= SD_BUF_SIZE - 2) {
+                        printk(KERN_ERR "%s: malformed MODE SENSE response",
+                                diskname);
+                        goto defaults;
+                }
+
                 if ((buffer[offset] & 0x3f) != modepage) {
                         printk(KERN_ERR "%s: got wrong page\n", diskname);
                         goto defaults;
@@ -1398,6 +1411,7 @@ defaults:
                diskname);
         sdkp->WCE = 0;
         sdkp->RCD = 0;
+        sdkp->DPOFUA = 0;
 }
 
 /**
@@ -1421,7 +1435,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         if (!scsi_device_online(sdp))
                 goto out;
 
-        buffer = kmalloc(512, GFP_KERNEL | __GFP_DMA);
+        buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL | __GFP_DMA);
         if (!buffer) {
                 printk(KERN_WARNING "(sd_revalidate_disk:) Memory allocation "
                        "failure.\n");
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index b1fc97d5f643..7aca22c9976d 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2198,7 +2198,7 @@ serial8250_console_write(struct console *co, const char *s, unsigned int count)
         touch_nmi_watchdog();
 
         /*
-         *      First save the UER then disable the interrupts
+         *      First save the IER then disable the interrupts
          */
         ier = serial_in(up, UART_IER);
 
@@ -2326,6 +2326,12 @@ static struct uart_driver serial8250_reg = {
         .cons                   = SERIAL8250_CONSOLE,
 };
 
+/*
+ * early_serial_setup - early registration for 8250 ports
+ *
+ * Setup an 8250 port structure prior to console initialisation.  Use
+ * after console initialisation will cause undefined behaviour.
+ */
 int __init early_serial_setup(struct uart_port *port)
 {
         if (port->line >= ARRAY_SIZE(serial8250_ports))
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 0f4361c8466b..b3c561abe3f6 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -902,8 +902,8 @@ config SERIAL_JSM
           something like this to connect more than two modems to your Linux
           box, for instance in order to become a dial-in server. This driver
           supports PCI boards only.
-          If you have a card like this, say Y here and read the file
-          <file:Documentation/jsm.txt>.
+
+          If you have a card like this, say Y here, otherwise say N.
 
           To compile this driver as a module, choose M here: the
           module will be called jsm.
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 791c4dc550ae..94f5e8ed83a7 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -90,7 +90,7 @@ static int spi_suspend(struct device *dev, pm_message_t message)
         int                     value;
         struct spi_driver       *drv = to_spi_driver(dev->driver);
 
-        if (!drv->suspend)
+        if (!drv || !drv->suspend)
                 return 0;
 
         /* suspend will stop irqs and dma; no more i/o */
@@ -105,7 +105,7 @@ static int spi_resume(struct device *dev)
         int                     value;
         struct spi_driver       *drv = to_spi_driver(dev->driver);
 
-        if (!drv->resume)
+        if (!drv || !drv->resume)
                 return 0;
 
         /* resume may restart the i/o queue */
@@ -449,7 +449,6 @@ void spi_unregister_master(struct spi_master *master)
 {
         (void) device_for_each_child(master->cdev.dev, NULL, __unregister);
         class_device_unregister(&master->cdev);
-        master->cdev.dev = NULL;
 }
 EXPORT_SYMBOL_GPL(spi_unregister_master);
 
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index e64ed16bd42f..f5079c78ba4e 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -520,7 +520,7 @@ config FB_GBE
 config FB_GBE_MEM
         int "Video memory size in MB"
         depends on FB_GBE
-        default 8
+        default 4
         help
           This is the amount of memory reserved for the framebuffer,
           which can be any value between 1MB and 8MB.
diff --git a/drivers/video/asiliantfb.c b/drivers/video/asiliantfb.c
index 69f75547865d..c924d81f7978 100644
--- a/drivers/video/asiliantfb.c
+++ b/drivers/video/asiliantfb.c
@@ -322,32 +322,29 @@ static int asiliantfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
         writeb(green, mmio_base + 0x791);
         writeb(blue, mmio_base + 0x791);
 
-        switch(p->var.bits_per_pixel) {
-        case 15:
-                if (regno < 16) {
+        if (regno < 16) {
+                switch(p->var.red.offset) {
+                case 10: /* RGB 555 */
                         ((u32 *)(p->pseudo_palette))[regno] =
                                 ((red & 0xf8) << 7) |
                                 ((green & 0xf8) << 2) |
                                 ((blue & 0xf8) >> 3);
-                }
-                break;
-        case 16:
-                if (regno < 16) {
+                        break;
+                case 11: /* RGB 565 */
                         ((u32 *)(p->pseudo_palette))[regno] =
                                 ((red & 0xf8) << 8) |
                                 ((green & 0xfc) << 3) |
                                 ((blue & 0xf8) >> 3);
-                }
-                break;
-        case 24:
-                if (regno < 24) {
+                        break;
+                case 16: /* RGB 888 */
                         ((u32 *)(p->pseudo_palette))[regno] =
                                 (red << 16)  |
                                 (green << 8) |
                                 (blue);
+                        break;
                 }
-                break;
         }
+
         return 0;
 }
 
diff --git a/drivers/video/aty/radeon_pm.c b/drivers/video/aty/radeon_pm.c
index 556895e99645..1f8d805c61e5 100644
--- a/drivers/video/aty/radeon_pm.c
+++ b/drivers/video/aty/radeon_pm.c
@@ -1321,8 +1321,6 @@ static void radeon_pm_full_reset_sdram(struct radeonfb_info *rinfo)
         mdelay( 15);
 }
 
-#ifdef CONFIG_PPC_OF
-
 static void radeon_pm_reset_pad_ctlr_strength(struct radeonfb_info *rinfo)
 {
         u32 tmp, tmp2;
@@ -1836,6 +1834,8 @@ static void radeon_reinitialize_M10(struct radeonfb_info *rinfo)
         radeon_pm_m10_enable_lvds_spread_spectrum(rinfo);
 }
 
+#ifdef CONFIG_PPC_OF
+
 static void radeon_pm_m9p_reconfigure_mc(struct radeonfb_info *rinfo)
 {
         OUTREG(MC_CNTL, rinfo->save_regs[46]);
@@ -2728,13 +2728,23 @@ void radeonfb_pm_init(struct radeonfb_info *rinfo, int dynclk)
                 printk("radeonfb: Dynamic Clock Power Management disabled\n");
         }
 
+#if defined(CONFIG_PM)
         /* Check if we can power manage on suspend/resume. We can do
          * D2 on M6, M7 and M9, and we can resume from D3 cold a few other
          * "Mac" cards, but that's all. We need more infos about what the
          * BIOS does tho. Right now, all this PM stuff is pmac-only for that
          * reason. --BenH
          */
-#if defined(CONFIG_PM) && defined(CONFIG_PPC_PMAC)
+        /* Special case for Samsung P35 laptops
+         */
+        if ((rinfo->pdev->vendor == PCI_VENDOR_ID_ATI) &&
+            (rinfo->pdev->device == PCI_CHIP_RV350_NP) &&
+            (rinfo->pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG) &&
+            (rinfo->pdev->subsystem_device == 0xc00c)) {
+                rinfo->reinit_func = radeon_reinitialize_M10;
+                rinfo->pm_mode |= radeon_pm_off;
+        }
+#if defined(CONFIG_PPC_PMAC)
         if (_machine == _MACH_Pmac && rinfo->of_node) {
                 if (rinfo->is_mobility && rinfo->pm_reg &&
                     rinfo->family <= CHIP_FAMILY_RV250)
@@ -2778,7 +2788,8 @@ void radeonfb_pm_init(struct radeonfb_info *rinfo, int dynclk)
                 OUTREG(TV_DAC_CNTL, INREG(TV_DAC_CNTL) | 0x07000000);
 #endif
         }
-#endif /* defined(CONFIG_PM) && defined(CONFIG_PPC_PMAC) */
+#endif /* defined(CONFIG_PPC_PMAC) */
+#endif /* defined(CONFIG_PM) */
 }
 
 void radeonfb_pm_exit(struct radeonfb_info *rinfo)
diff --git a/drivers/video/au1100fb.c b/drivers/video/au1100fb.c
index 2406899f1207..3d04b2def0f1 100644
--- a/drivers/video/au1100fb.c
+++ b/drivers/video/au1100fb.c
@@ -49,6 +49,7 @@
 #include <linux/interrupt.h>
 #include <linux/ctype.h>
 #include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
 
 #include <asm/mach-au1x00/au1000.h>
 
@@ -406,7 +407,7 @@ int au1100fb_fb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
 
         vma->vm_flags |= VM_IO;
 
-        if (io_remap_page_range(vma, vma->vm_start, off,
+        if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
                                 vma->vm_end - vma->vm_start,
                                 vma->vm_page_prot)) {
                 return -EAGAIN;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 12d9329d1408..5a86978537d2 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -509,57 +509,60 @@ static int vgacon_doresize(struct vc_data *c,
 {
         unsigned long flags;
         unsigned int scanlines = height * c->vc_font.height;
-        u8 scanlines_lo, r7, vsync_end, mode, max_scan;
+        u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
 
         spin_lock_irqsave(&vga_lock, flags);
 
-        outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
-        max_scan = inb_p(vga_video_port_val);
-
-        if (max_scan & 0x80)
-                scanlines <<= 1;
-
         vgacon_xres = width * VGA_FONTWIDTH;
         vgacon_yres = height * c->vc_font.height;
-        outb_p(VGA_CRTC_MODE, vga_video_port_reg);
-        mode = inb_p(vga_video_port_val);
+        if (vga_video_type >= VIDEO_TYPE_VGAC) {
+                outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
+                max_scan = inb_p(vga_video_port_val);
 
-        if (mode & 0x04)
-                scanlines >>= 1;
+                if (max_scan & 0x80)
+                        scanlines <<= 1;
 
-        scanlines -= 1;
-        scanlines_lo = scanlines & 0xff;
+                outb_p(VGA_CRTC_MODE, vga_video_port_reg);
+                mode = inb_p(vga_video_port_val);
 
-        outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
-        r7 = inb_p(vga_video_port_val) & ~0x42;
+                if (mode & 0x04)
+                        scanlines >>= 1;
 
-        if (scanlines & 0x100)
-                r7 |= 0x02;
-        if (scanlines & 0x200)
-                r7 |= 0x40;
+                scanlines -= 1;
+                scanlines_lo = scanlines & 0xff;
 
-        /* deprotect registers */
-        outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
-        vsync_end = inb_p(vga_video_port_val);
-        outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
-        outb_p(vsync_end & ~0x80, vga_video_port_val);
+                outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
+                r7 = inb_p(vga_video_port_val) & ~0x42;
+
+                if (scanlines & 0x100)
+                        r7 |= 0x02;
+                if (scanlines & 0x200)
+                        r7 |= 0x40;
+
+                /* deprotect registers */
+                outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
+                vsync_end = inb_p(vga_video_port_val);
+                outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
+                outb_p(vsync_end & ~0x80, vga_video_port_val);
+        }
 
         outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
         outb_p(width - 1, vga_video_port_val);
         outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
         outb_p(width >> 1, vga_video_port_val);
 
-        outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
-        outb_p(scanlines_lo, vga_video_port_val);
-        outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
-        outb_p(r7,vga_video_port_val);
+        if (vga_video_type >= VIDEO_TYPE_VGAC) {
+                outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
+                outb_p(scanlines_lo, vga_video_port_val);
+                outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
+                outb_p(r7,vga_video_port_val);
 
-        /* reprotect registers */
-        outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
-        outb_p(vsync_end, vga_video_port_val);
+                /* reprotect registers */
+                outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
+                outb_p(vsync_end, vga_video_port_val);
+        }
 
         spin_unlock_irqrestore(&vga_lock, flags);
-
         return 0;
 }
 
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index 38d22729b129..5e25b9860196 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -656,12 +656,15 @@ static int gbefb_set_par(struct fb_info *info)
         switch (bytesPerPixel) {
         case 1:
                 SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_I8);
+                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
                 break;
         case 2:
                 SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_ARGB5);
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
                 break;
         case 4:
                 SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_RGB8);
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
                 break;
         }
         SET_GBE_FIELD(WID, BUF, val, GBE_BMODE_BOTH);
@@ -1243,7 +1246,7 @@ static int __devexit gbefb_remove(struct platform_device* p_dev)
                           (void *)gbe_tiles.cpu, gbe_tiles.dma);
         release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
         iounmap(gbe);
-        gbefb_remove_sysfs(dev);
+        gbefb_remove_sysfs(&p_dev->dev);
         framebuffer_release(info);
 
         return 0;
diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c
index d574dd3c9c8a..9451932fbaf2 100644
--- a/drivers/video/s3c2410fb.c
+++ b/drivers/video/s3c2410fb.c
@@ -82,7 +82,6 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
-#include <linux/string.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
 #include <linux/wait.h>