106 files changed, 2499 insertions, 961 deletions
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 3f4aa0c99ee4..03f6338acc8f 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -6,6 +6,7 @@ menu "Serial ATA (prod) and Parallel ATA (experimental) drivers"
 config ATA
        tristate "ATA device support"
+        depends on BLOCK
        depends on !(M32R || M68K) || BROKEN
        depends on !SUN4 || BROKEN
        select SCSI
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 25929123ffff..cef2e70d64f8 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -1041,7 +1041,7 @@ static void ahci_host_intr(struct ata_port *ap)
        /* hmmm... a spurious interupt */
        /* some devices send D2H reg with I bit set during NCQ command phase */
-        if (ap->sactive && status & PORT_IRQ_D2H_REG_FIS)
+        if (ap->sactive && (status & PORT_IRQ_D2H_REG_FIS))
                return;
        /* ignore interim PIO setup fis interrupts */
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 5719704eb0ee..5250187ffce2 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -432,9 +432,9 @@ static const struct piix_map_db ich8_map_db = {
        .present_shift = 8,
        .map = {
                /* PM   PS   SM   SS       MAP */
-                {  P0,  NA,  P1,  NA }, /* 00b (hardwired) */
+                {  P0,  P2,  P1,  P3 }, /* 00b (hardwired when in AHCI) */
                {  RV,  RV,  RV,  RV },
-                {  RV,  RV,  RV,  RV }, /* 10b (never) */
+                {  IDE,  IDE,  NA,  NA }, /* 10b (IDE mode) */
                {  RV,  RV,  RV,  RV },
        },
 };
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 06daaa3736a2..7645f2b30ccf 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -981,6 +981,15 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
                mask = (1 << 2) | (1 << 0);
                if ((tmp8 & mask) != mask)
                        legacy_mode = (1 << 3);
+#if defined(CONFIG_NO_ATA_LEGACY)
+                /* Some platforms with PCI limits cannot address compat
+                   port space. In that case we punt if their firmware has
+                   left a device in compatibility mode */
+                if (legacy_mode) {
+                        printk(KERN_ERR "ata: Compatibility mode ATA is not supported on this platform, skipping.\n");
+                        return -EOPNOTSUPP;
+                }
+#endif
        }
        rc = pci_request_regions(pdev, DRV_NAME);
diff --git a/drivers/atm/ambassador.c b/drivers/atm/ambassador.c
index 323592de047b..9fffa7af6db1 100644
--- a/drivers/atm/ambassador.c
+++ b/drivers/atm/ambassador.c
@@ -2452,8 +2452,8 @@ static int __init amb_module_init (void)
 static void __exit amb_module_exit (void)
 {
  PRINTD (DBG_FLOW|DBG_INIT, "cleanup_module");
-  
-  return pci_unregister_driver(&amb_driver);
+  pci_unregister_driver(&amb_driver);
 }
 module_init(amb_module_init);
diff --git a/drivers/atm/firestream.c b/drivers/atm/firestream.c
index 40ab9b65fae9..697ad82f6634 100644
--- a/drivers/atm/firestream.c
+++ b/drivers/atm/firestream.c
@@ -1002,6 +1002,10 @@ static int fs_open(struct atm_vcc *atm_vcc)
                                        r = ROUND_UP;
                                }
                                error = make_rate (pcr, r, &tmc0, NULL);
+                                if (error) {
+                                        kfree(tc);
+                                        return error;
+                                }
                        }
                        fs_dprintk (FS_DEBUG_OPEN, "pcr = %d.\n", pcr);
                }
diff --git a/drivers/atm/horizon.c b/drivers/atm/horizon.c
index f59349206dd2..4dc10105d610 100644
--- a/drivers/atm/horizon.c
+++ b/drivers/atm/horizon.c
@@ -1789,7 +1789,7 @@ static inline void CLOCK_IT (const hrz_dev *dev, u32 ctrl)
        WRITE_IT_WAIT(dev, ctrl | SEEPROM_SK);
 }
-static u16 __init read_bia (const hrz_dev * dev, u16 addr)
+static u16 __devinit read_bia (const hrz_dev * dev, u16 addr)
 {
  u32 ctrl = rd_regl (dev, CONTROL_0_REG);
  
@@ -2932,8 +2932,8 @@ static int __init hrz_module_init (void) {
 static void __exit hrz_module_exit (void) {
  PRINTD (DBG_FLOW, "cleanup_module");
-  
-  return pci_unregister_driver(&hrz_driver);
+  pci_unregister_driver(&hrz_driver);
 }
 module_init(hrz_module_init);
diff --git a/drivers/atm/nicstar.c b/drivers/atm/nicstar.c
index 632ede552761..bd0904594805 100644
--- a/drivers/atm/nicstar.c
+++ b/drivers/atm/nicstar.c
@@ -2759,7 +2759,7 @@ static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
 {
   ns_dev *card;
   pool_levels pl;
-   int btype;
+   long btype;
   unsigned long flags;
   card = dev->dev_data;
@@ -2859,7 +2859,7 @@ static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
      case NS_ADJBUFLEV:
         if (!capable(CAP_NET_ADMIN))
            return -EPERM;
-         btype = (int) arg;     /* an int is the same size as a pointer */
+         btype = (long) arg;    /* a long is the same size as a pointer or bigger */
         switch (btype)
         {
            case NS_BUFTYPE_SMALL:
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index dcccaf2782f3..bc6602606fb5 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -1923,7 +1923,6 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
 {
        int return_code;
        unsigned long t;
-        unsigned long rem;
        memset(inq_buff, 0, sizeof(InquiryData_struct));
        if (withirq)
@@ -1939,26 +1938,23 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
                        printk(KERN_WARNING
                               "cciss: reading geometry failed, volume "
                               "does not support reading geometry\n");
-                        drv->block_size = block_size;
-                        drv->nr_blocks = total_size;
                        drv->heads = 255;
                        drv->sectors = 32;      // Sectors per track
-                        t = drv->heads * drv->sectors;
-                        drv->cylinders = total_size;
-                        rem = do_div(drv->cylinders, t);
                } else {
-                        drv->block_size = block_size;
-                        drv->nr_blocks = total_size;
                        drv->heads = inq_buff->data_byte[6];
                        drv->sectors = inq_buff->data_byte[7];
                        drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
                        drv->cylinders += inq_buff->data_byte[5];
                        drv->raid_level = inq_buff->data_byte[8];
-                        t = drv->heads * drv->sectors;
+                }
-                        if (t > 1) {
+                drv->block_size = block_size;
-                                drv->cylinders = total_size;
+                drv->nr_blocks = total_size;
-                                rem = do_div(drv->cylinders, t);
+                t = drv->heads * drv->sectors;
-                        }
+                if (t > 1) {
+                        unsigned rem = sector_div(total_size, t);
+                        if (rem)
+                                total_size++;
+                        drv->cylinders = total_size;
                }
        } else {                /* Get geometry failed */
                printk(KERN_WARNING "cciss: reading geometry failed\n");
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c
index 91b71e750ee1..dffc19382f7e 100644
--- a/drivers/char/agp/uninorth-agp.c
+++ b/drivers/char/agp/uninorth-agp.c
@@ -27,32 +27,42 @@
 static int uninorth_rev;
 static int is_u3;
+static char __devinitdata *aperture = NULL;
 static int uninorth_fetch_size(void)
 {
-        int i;
+        int i, size = 0;
-        u32 temp;
+        struct aper_size_info_32 *values =
-        struct aper_size_info_32 *values;
+            A_SIZE_32(agp_bridge->driver->aperture_sizes);
-        pci_read_config_dword(agp_bridge->dev, UNI_N_CFG_GART_BASE, &temp);
+        if (aperture) {
-        temp &= ~(0xfffff000);
+                char *save = aperture;
-        values = A_SIZE_32(agp_bridge->driver->aperture_sizes);
+                size = memparse(aperture, &aperture) >> 20;
-        for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
+                aperture = save;
-                if (temp == values[i].size_value) {
-                        agp_bridge->previous_size =
+                for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++)
-                            agp_bridge->current_size = (void *) (values + i);
+                        if (size == values[i].size)
-                        agp_bridge->aperture_size_idx = i;
+                                break;
-                        return values[i].size;
+                if (i == agp_bridge->driver->num_aperture_sizes) {
+                        printk(KERN_ERR PFX "Invalid aperture size, using"
+                               " default\n");
+                        size = 0;
+                        aperture = NULL;
                }
        }
-        agp_bridge->previous_size =
+        if (!size) {
-            agp_bridge->current_size = (void *) (values + 1);
+                for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++)
-        agp_bridge->aperture_size_idx = 1;
+                        if (values[i].size == 32)
-        return values[1].size;
+                                break;
+        }
-        return 0;
+        agp_bridge->previous_size =
+            agp_bridge->current_size = (void *)(values + i);
+        agp_bridge->aperture_size_idx = i;
+        return values[i].size;
 }
 static void uninorth_tlbflush(struct agp_memory *mem)
@@ -683,5 +693,11 @@ static void __exit agp_uninorth_cleanup(void)
 module_init(agp_uninorth_init);
 module_exit(agp_uninorth_cleanup);
+module_param(aperture, charp, 0);
+MODULE_PARM_DESC(aperture,
+                 "Aperture size, must be power of two between 4MB and an\n"
+                 "\t\tupper limit specific to the UniNorth revision.\n"
+                 "\t\tDefault: 32M");
 MODULE_AUTHOR("Ben Herrenschmidt & Paul Mackerras");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index 029baea33b62..6eafff13dab6 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -237,6 +237,8 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
        list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);
        if (!list) {
+                if (map->type == _DRM_REGISTERS)
+                        drm_ioremapfree(map->handle, map->size, dev);
                drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                return -EINVAL;
        }
@@ -252,6 +254,8 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
                map->offset;
        ret = drm_map_handle(dev, &list->hash, user_token, 0);
        if (ret) {
+                if (map->type == _DRM_REGISTERS)
+                        drm_ioremapfree(map->handle, map->size, dev);
                drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                drm_free(list, sizeof(*list), DRM_MEM_MAPS);
                mutex_unlock(&dev->struct_mutex);
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 51ad98c685c3..ba4b8de83cf0 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -42,13 +42,24 @@ static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
 struct class *drm_sysfs_create(struct module *owner, char *name)
 {
        struct class *class;
+        int err;
        class = class_create(owner, name);
-        if (!class)
+        if (!class) {
-                return class;
+                err = -ENOMEM;
+                goto err_out;
+        }
+        err = class_create_file(class, &class_attr_version);
+        if (err)
+                goto err_out_class;
-        class_create_file(class, &class_attr_version);
        return class;
+err_out_class:
+        class_destroy(class);
+err_out:
+        return ERR_PTR(err);
 }
 /**
@@ -96,20 +107,36 @@ static struct class_device_attribute class_device_attrs[] = {
 struct class_device *drm_sysfs_device_add(struct class *cs, drm_head_t *head)
 {
        struct class_device *class_dev;
-        int i;
+        int i, j, err;
        class_dev = class_device_create(cs, NULL,
                                        MKDEV(DRM_MAJOR, head->minor),
                                        &(head->dev->pdev)->dev,
                                        "card%d", head->minor);
-        if (!class_dev)
+        if (!class_dev) {
-                return NULL;
+                err = -ENOMEM;
+                goto err_out;
+        }
        class_set_devdata(class_dev, head);
-        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
+        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++) {
-                class_device_create_file(class_dev, &class_device_attrs[i]);
+                err = class_device_create_file(class_dev,
+                                               &class_device_attrs[i]);
+                if (err)
+                        goto err_out_files;
+        }
        return class_dev;
+err_out_files:
+        if (i > 0)
+                for (j = 0; j < i; j++)
+                        class_device_remove_file(class_dev,
+                                                 &class_device_attrs[i]);
+        class_device_unregister(class_dev);
+err_out:
+        return ERR_PTR(err);
 }
 /**
diff --git a/drivers/char/drm/mga_drv.c b/drivers/char/drm/mga_drv.c
index e30f556b79f1..be49dbb9ec3f 100644
--- a/drivers/char/drm/mga_drv.c
+++ b/drivers/char/drm/mga_drv.c
@@ -47,6 +47,7 @@ static struct drm_driver driver = {
            DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA |
            DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
            DRIVER_IRQ_VBL,
+        .dev_priv_size = sizeof(drm_mga_buf_priv_t),
        .load = mga_driver_load,
        .unload = mga_driver_unload,
        .lastclose = mga_driver_lastclose,
diff --git a/drivers/char/drm/r300_cmdbuf.c b/drivers/char/drm/r300_cmdbuf.c
index 26bdf2ca59d7..d14477ba3679 100644
--- a/drivers/char/drm/r300_cmdbuf.c
+++ b/drivers/char/drm/r300_cmdbuf.c
@@ -538,6 +538,36 @@ static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
        return 0;
 }
+static __inline__ int r300_emit_indx_buffer(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[1] & 0x8000ffff) != 0x80000810) {
+                DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
+                return DRM_ERR(EINVAL);
+        }
+        ret = r300_check_offset(dev_priv, cmd[2]);
+        if (ret) {
+                DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
+                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)
 {
@@ -578,10 +608,11 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
        case RADEON_CNTL_BITBLT_MULTI:
                return r300_emit_bitblt_multi(dev_priv, cmdbuf);
+        case RADEON_CP_INDX_BUFFER:     /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
+                return r300_emit_indx_buffer(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 */
-        case RADEON_CP_INDX_BUFFER:     /* DRAW_INDX_2 without INDX_BUFFER seems to lock up the gpu */
        case RADEON_WAIT_FOR_IDLE:
        case RADEON_CP_NOP:
                /* these packets are safe */
diff --git a/drivers/char/drm/radeon_state.c b/drivers/char/drm/radeon_state.c
index feac5f005d47..6e04fdd732ac 100644
--- a/drivers/char/drm/radeon_state.c
+++ b/drivers/char/drm/radeon_state.c
@@ -275,6 +275,8 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                                                     unsigned int *cmdsz)
 {
        u32 *cmd = (u32 *) cmdbuf->buf;
+        u32 offset, narrays;
+        int count, i, k;
        *cmdsz = 2 + ((cmd[0] & RADEON_CP_PACKET_COUNT_MASK) >> 16);
@@ -288,10 +290,106 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                return DRM_ERR(EINVAL);
        }
-        /* Check client state and fix it up if necessary */
+        switch(cmd[0] & 0xff00) {
-        if (cmd[0] & 0x8000) {  /* MSB of opcode: next DWORD GUI_CNTL */
+        /* XXX Are there old drivers needing other packets? */
-                u32 offset;
+        case RADEON_3D_DRAW_IMMD:
+        case RADEON_3D_DRAW_VBUF:
+        case RADEON_3D_DRAW_INDX:
+        case RADEON_WAIT_FOR_IDLE:
+        case RADEON_CP_NOP:
+        case RADEON_3D_CLEAR_ZMASK:
+/*      case RADEON_CP_NEXT_CHAR:
+        case RADEON_CP_PLY_NEXTSCAN:
+        case RADEON_CP_SET_SCISSORS: */ /* probably safe but will never need them? */
+                /* these packets are safe */
+                break;
+        case RADEON_CP_3D_DRAW_IMMD_2:
+        case RADEON_CP_3D_DRAW_VBUF_2:
+        case RADEON_CP_3D_DRAW_INDX_2:
+        case RADEON_3D_CLEAR_HIZ:
+                /* safe but r200 only */
+                if (dev_priv->microcode_version != UCODE_R200) {
+                        DRM_ERROR("Invalid 3d packet for r100-class chip\n");
+                        return DRM_ERR(EINVAL);
+                }
+                break;
+        case RADEON_3D_LOAD_VBPNTR:
+                count = (cmd[0] >> 16) & 0x3fff;
+                if (count > 18) { /* 12 arrays max */
+                        DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
+                                  count);
+                        return DRM_ERR(EINVAL);
+                }
+                /* carefully check packet contents */
+                narrays = cmd[1] & ~0xc000;
+                k = 0;
+                i = 2;
+                while ((k < narrays) && (i < (count + 2))) {
+                        i++;            /* skip attribute field */
+                        if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[i])) {
+                                DRM_ERROR
+                                    ("Invalid offset (k=%d i=%d) in 3D_LOAD_VBPNTR packet.\n",
+                                     k, i);
+                                return DRM_ERR(EINVAL);
+                        }
+                        k++;
+                        i++;
+                        if (k == narrays)
+                                break;
+                        /* have one more to process, they come in pairs */
+                        if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[i])) {
+                                DRM_ERROR
+                                    ("Invalid offset (k=%d i=%d) in 3D_LOAD_VBPNTR packet.\n",
+                                     k, i);
+                                return DRM_ERR(EINVAL);
+                        }
+                        k++;
+                        i++;
+                }
+                /* do the counts match what we expect ? */
+                if ((k != narrays) || (i != (count + 2))) {
+                        DRM_ERROR
+                            ("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
+                              k, i, narrays, count + 1);
+                        return DRM_ERR(EINVAL);
+                }
+                break;
+        case RADEON_3D_RNDR_GEN_INDX_PRIM:
+                if (dev_priv->microcode_version != UCODE_R100) {
+                        DRM_ERROR("Invalid 3d packet for r200-class chip\n");
+                        return DRM_ERR(EINVAL);
+                }
+                if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[1])) {
+                                DRM_ERROR("Invalid rndr_gen_indx offset\n");
+                                return DRM_ERR(EINVAL);
+                }
+                break;
+        case RADEON_CP_INDX_BUFFER:
+                if (dev_priv->microcode_version != UCODE_R200) {
+                        DRM_ERROR("Invalid 3d packet for r100-class chip\n");
+                        return DRM_ERR(EINVAL);
+                }
+                if ((cmd[1] & 0x8000ffff) != 0x80000810) {
+                        DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
+                        return DRM_ERR(EINVAL);
+                }
+                if (radeon_check_and_fixup_offset(dev_priv, filp_priv, &cmd[2])) {
+                        DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
+                        return DRM_ERR(EINVAL);
+                }
+                break;
+        case RADEON_CNTL_HOSTDATA_BLT:
+        case RADEON_CNTL_PAINT_MULTI:
+        case RADEON_CNTL_BITBLT_MULTI:
+                /* MSB of opcode: next DWORD GUI_CNTL */
                if (cmd[1] & (RADEON_GMC_SRC_PITCH_OFFSET_CNTL
                              | RADEON_GMC_DST_PITCH_OFFSET_CNTL)) {
                        offset = cmd[2] << 10;
@@ -313,6 +411,11 @@ static __inline__ int radeon_check_and_fixup_packet3(drm_radeon_private_t *
                        }
                        cmd[3] = (cmd[3] & 0xffc00000) | offset >> 10;
                }
+                break;
+        default:
+                DRM_ERROR("Invalid packet type %x\n", cmd[0] & 0xff00);
+                return DRM_ERR(EINVAL);
        }
        return 0;
diff --git a/drivers/char/drm/savage_bci.c b/drivers/char/drm/savage_bci.c
index 59c7520bf9a2..a9a84f88df5e 100644
--- a/drivers/char/drm/savage_bci.c
+++ b/drivers/char/drm/savage_bci.c
@@ -728,6 +728,7 @@ static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
                dev_priv->status = NULL;
        }
        if (dev_priv->dma_type == SAVAGE_DMA_AGP && init->buffers_offset) {
+                dev->agp_buffer_token = init->buffers_offset;
                dev->agp_buffer_map = drm_core_findmap(dev,
                                                       init->buffers_offset);
                if (!dev->agp_buffer_map) {
diff --git a/drivers/char/drm/savage_state.c b/drivers/char/drm/savage_state.c
index ef2581d16146..1ca1e9cb5a33 100644
--- a/drivers/char/drm/savage_state.c
+++ b/drivers/char/drm/savage_state.c
@@ -994,7 +994,7 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
        if (cmdbuf.size) {
                kcmd_addr = drm_alloc(cmdbuf.size * 8, DRM_MEM_DRIVER);
                if (kcmd_addr == NULL)
-                        return ENOMEM;
+                        return DRM_ERR(ENOMEM);
                if (DRM_COPY_FROM_USER(kcmd_addr, cmdbuf.cmd_addr,
                                       cmdbuf.size * 8))
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index b401383808c2..96cb1f07332b 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -130,6 +130,7 @@ static moxa_isa_board_conf moxa_isa_boards[] =
 typedef struct _moxa_pci_devinfo {
        ushort busNum;
        ushort devNum;
+        struct pci_dev *pdev;
 } moxa_pci_devinfo;
 typedef struct _moxa_board_conf {
@@ -324,6 +325,9 @@ static int moxa_get_PCI_conf(struct pci_dev *p, int board_type, moxa_board_conf
        board->busType = MOXA_BUS_TYPE_PCI;
        board->pciInfo.busNum = p->bus->number;
        board->pciInfo.devNum = p->devfn >> 3;
+        board->pciInfo.pdev = p;
+        /* don't lose the reference in the next pci_get_device iteration */
+        pci_dev_get(p);
        return (0);
 }
@@ -493,6 +497,11 @@ static void __exit moxa_exit(void)
        if (tty_unregister_driver(moxaDriver))
                printk("Couldn't unregister MOXA Intellio family serial driver\n");
        put_tty_driver(moxaDriver);
+        for (i = 0; i < MAX_BOARDS; i++)
+                if (moxa_boards[i].busType == MOXA_BUS_TYPE_PCI)
+                        pci_dev_put(moxa_boards[i].pciInfo.pdev);
        if (verbose)
                printk("Done\n");
 }
diff --git a/drivers/char/rio/host.h b/drivers/char/rio/host.h
index ee2ddea7a63a..23d0681fe491 100644
--- a/drivers/char/rio/host.h
+++ b/drivers/char/rio/host.h
@@ -44,6 +44,7 @@
 **    the host.
 */
 struct Host {
+        struct pci_dev *pdev;
        unsigned char Type;             /* RIO_EISA, RIO_MCA, ... */
        unsigned char Ivec;             /* POLLED or ivec number */
        unsigned char Mode;             /* Control stuff */
diff --git a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c
index c382df0f82f6..7ac68cb3bedd 100644
--- a/drivers/char/rio/rio_linux.c
+++ b/drivers/char/rio/rio_linux.c
@@ -1017,6 +1017,10 @@ static int __init rio_init(void)
                        rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
                        fix_rio_pci(pdev);
+                        p->RIOHosts[p->RIONumHosts].pdev = pdev;
+                        pci_dev_get(pdev);
                        p->RIOLastPCISearch = 0;
                        p->RIONumHosts++;
                        found++;
@@ -1066,6 +1070,9 @@ static int __init rio_init(void)
                            ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
                        rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
+                        p->RIOHosts[p->RIONumHosts].pdev = pdev;
+                        pci_dev_get(pdev);
                        p->RIOLastPCISearch = 0;
                        p->RIONumHosts++;
                        found++;
@@ -1181,6 +1188,8 @@ static void __exit rio_exit(void)
                }
                /* It is safe/allowed to del_timer a non-active timer */
                del_timer(&hp->timer);
+                if (hp->Type == RIO_PCI)
+                        pci_dev_put(hp->pdev);
        }
        if (misc_deregister(&rio_fw_device) < 0) {
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig
index 89e46d6dfc4e..0187b1185323 100644
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -13,7 +13,7 @@ config WATCHDOG
          subsequently opening the file and then failing to write to it for
          longer than 1 minute will result in rebooting the machine. This
          could be useful for a networked machine that needs to come back
-          online as fast as possible after a lock-up. There's both a watchdog
+          on-line as fast as possible after a lock-up. There's both a watchdog
          implementation entirely in software (which can sometimes fail to
          reboot the machine) and a driver for hardware watchdog boards, which
          are more robust and can also keep track of the temperature inside
@@ -60,7 +60,7 @@ config SOFT_WATCHDOG
 # ARM Architecture
-config AT91_WATCHDOG
+config AT91RM9200_WATCHDOG
        tristate "AT91RM9200 watchdog"
        depends on WATCHDOG && ARCH_AT91RM9200
        help
@@ -71,7 +71,7 @@ config 21285_WATCHDOG
        tristate "DC21285 watchdog"
        depends on WATCHDOG && FOOTBRIDGE
        help
-          The Intel Footbridge chip contains a builtin watchdog circuit. Say Y
+          The Intel Footbridge chip contains a built-in watchdog circuit. Say Y
          here if you wish to use this. Alternatively say M to compile the
          driver as a module, which will be called wdt285.
@@ -269,11 +269,11 @@ config IB700_WDT
          Most people will say N.
 config IBMASR
-        tristate "IBM Automatic Server Restart"
+        tristate "IBM Automatic Server Restart"
-        depends on WATCHDOG && X86
+        depends on WATCHDOG && X86
-        help
+        help
          This is the driver for the IBM Automatic Server Restart watchdog
-          timer builtin into some eServer xSeries machines.
+          timer built-in into some eServer xSeries machines.
          To compile this driver as a module, choose M here: the
          module will be called ibmasr.
@@ -316,13 +316,16 @@ config I8XX_TCO
          To compile this driver as a module, choose M here: the
          module will be called i8xx_tco.
+          Note: This driver will be removed in the near future. Please
+          use the Intel TCO Timer/Watchdog driver.
 config ITCO_WDT
-        tristate "Intel TCO Timer/Watchdog (EXPERIMENTAL)"
+        tristate "Intel TCO Timer/Watchdog"
-        depends on WATCHDOG && (X86 || IA64) && PCI && EXPERIMENTAL
+        depends on WATCHDOG && (X86 || IA64) && PCI
        ---help---
          Hardware driver for the intel TCO timer based watchdog devices.
          These drivers are included in the Intel 82801 I/O Controller
-          Hub family 'from ICH0 up to ICH7) and in the Intel 6300ESB
+          Hub family (from ICH0 up to ICH8) and in the Intel 6300ESB
          controller hub.
          The TCO (Total Cost of Ownership) timer is a watchdog timer
@@ -395,6 +398,26 @@ config CPU5_WDT
          To compile this driver as a module, choose M here: the
          module will be called cpu5wdt.
+config SMSC37B787_WDT
+        tristate "Winbond SMsC37B787 Watchdog Timer"
+        depends on WATCHDOG && X86
+        ---help---
+          This is the driver for the hardware watchdog component on the
+          Winbond SMsC37B787 chipset as used on the NetRunner Mainboard
+          from Vision Systems and maybe others.
+          This watchdog simply watches your kernel to make sure it doesn't
+          freeze, and if it does, it reboots your computer after a certain
+          amount of time.
+          Usually a userspace daemon will notify the kernel WDT driver that
+          userspace is still alive, at regular intervals.
+          To compile this driver as a module, choose M here: the
+          module will be called smsc37b787_wdt.
+          Most people will say N.
 config W83627HF_WDT
        tristate "W83627HF Watchdog Timer"
        depends on WATCHDOG && X86
@@ -410,6 +433,21 @@ config W83627HF_WDT
          Most people will say N.
+config W83697HF_WDT
+        tristate "W83697HF/W83697HG Watchdog Timer"
+        depends on WATCHDOG && X86
+        ---help---
+          This is the driver for the hardware watchdog on the W83697HF/HG
+          chipset as used in Dedibox/VIA motherboards (and likely others).
+          This watchdog simply watches your kernel to make sure it doesn't
+          freeze, and if it does, it reboots your computer after a certain
+          amount of time.
+          To compile this driver as a module, choose M here: the
+          module will be called w83697hf_wdt.
+          Most people will say N.
 config W83877F_WDT
        tristate "W83877F (EMACS) Watchdog Timer"
        depends on WATCHDOG && X86
@@ -443,7 +481,7 @@ config MACHZ_WDT
        depends on WATCHDOG && X86
        ---help---
          If you are using a ZF Micro MachZ processor, say Y here, otherwise
-          N.  This is the driver for the watchdog timer builtin on that
+          N.  This is the driver for the watchdog timer built-in on that
          processor using ZF-Logic interface.  This watchdog simply watches
          your kernel to make sure it doesn't freeze, and if it does, it
          reboots your computer after a certain amount of time.
@@ -472,7 +510,6 @@ config SBC_EPX_C3_WATCHDOG
          To compile this driver as a module, choose M here: the
          module will be called sbc_epx_c3.
 # PowerPC Architecture
 config 8xx_WDT
@@ -502,7 +539,7 @@ config WATCHDOG_RTAS
        help
          This driver adds watchdog support for the RTAS watchdog.
-          To compile this driver as a module, choose M here. The module
+          To compile this driver as a module, choose M here. The module
          will be called wdrtas.
 # MIPS Architecture
@@ -556,7 +593,7 @@ config SH_WDT_MMAP
        help
          If you say Y here, user applications will be able to mmap the
          WDT/CPG registers.
-#
 # SPARC64 Architecture
 config WATCHDOG_CP1XXX
diff --git a/drivers/char/watchdog/Makefile b/drivers/char/watchdog/Makefile
index 7f70abad465a..36440497047c 100644
--- a/drivers/char/watchdog/Makefile
+++ b/drivers/char/watchdog/Makefile
@@ -23,7 +23,7 @@ obj-$(CONFIG_WDTPCI) += wdt_pci.o
 obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
 # ARM Architecture
-obj-$(CONFIG_AT91_WATCHDOG) += at91_wdt.o
+obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
 obj-$(CONFIG_OMAP_WATCHDOG) += omap_wdt.o
 obj-$(CONFIG_21285_WATCHDOG) += wdt285.o
 obj-$(CONFIG_977_WATCHDOG) += wdt977.o
@@ -53,7 +53,9 @@ obj-$(CONFIG_SCx200_WDT) += scx200_wdt.o
 obj-$(CONFIG_60XX_WDT) += sbc60xxwdt.o
 obj-$(CONFIG_SBC8360_WDT) += sbc8360.o
 obj-$(CONFIG_CPU5_WDT) += cpu5wdt.o
+obj-$(CONFIG_SMSC37B787_WDT) += smsc37b787_wdt.o
 obj-$(CONFIG_W83627HF_WDT) += w83627hf_wdt.o
+obj-$(CONFIG_W83697HF_WDT) += w83697hf_wdt.o
 obj-$(CONFIG_W83877F_WDT) += w83877f_wdt.o
 obj-$(CONFIG_W83977F_WDT) += w83977f_wdt.o
 obj-$(CONFIG_MACHZ_WDT) += machzwd.o
diff --git a/drivers/char/watchdog/at91_wdt.c b/drivers/char/watchdog/at91rm9200_wdt.c
index 4e7a1145e78f..4e7a1145e78f 100644
--- a/drivers/char/watchdog/at91_wdt.c
+++ b/drivers/char/watchdog/at91rm9200_wdt.c
diff --git a/drivers/char/watchdog/iTCO_wdt.c b/drivers/char/watchdog/iTCO_wdt.c
index aaac94db0d8b..b6f29cb8bd39 100644
--- a/drivers/char/watchdog/iTCO_wdt.c
+++ b/drivers/char/watchdog/iTCO_wdt.c
@@ -35,6 +35,10 @@
 *      82801GDH (ICH7DH)    : document number 307013-002, 307014-009,
 *      82801GBM (ICH7-M)    : document number 307013-002, 307014-009,
 *      82801GHM (ICH7-M DH) : document number 307013-002, 307014-009,
+ *      82801HB  (ICH8)      : document number 313056-002, 313057-004,
+ *      82801HR  (ICH8R)     : document number 313056-002, 313057-004,
+ *      82801HH  (ICH8DH)    : document number 313056-002, 313057-004,
+ *      82801HO  (ICH8DO)    : document number 313056-002, 313057-004,
 *      6300ESB  (6300ESB)   : document number 300641-003
 */
@@ -45,7 +49,7 @@
 /* Module and version information */
 #define DRV_NAME        "iTCO_wdt"
 #define DRV_VERSION     "1.00"
-#define DRV_RELDATE     "30-Jul-2006"
+#define DRV_RELDATE     "08-Oct-2006"
 #define PFX             DRV_NAME ": "
 /* Includes */
@@ -85,6 +89,9 @@ enum iTCO_chipsets {
        TCO_ICH7,       /* ICH7 & ICH7R */
        TCO_ICH7M,      /* ICH7-M */
        TCO_ICH7MDH,    /* ICH7-M DH */
+        TCO_ICH8,       /* ICH8 & ICH8R */
+        TCO_ICH8DH,     /* ICH8DH */
+        TCO_ICH8DO,     /* ICH8DO */
 };
 static struct {
@@ -108,6 +115,9 @@ static struct {
        {"ICH7 or ICH7R", 2},
        {"ICH7-M", 2},
        {"ICH7-M DH", 2},
+        {"ICH8 or ICH8R", 2},
+        {"ICH8DH", 2},
+        {"ICH8DO", 2},
        {NULL,0}
 };
@@ -135,6 +145,9 @@ static struct pci_device_id iTCO_wdt_pci_tbl[] = {
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7    },
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_1,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7M   },
        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_31,     PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7MDH },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_0,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH8    },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_2,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH8DH  },
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_3,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH8DO  },
        { 0, },                 /* End of list */
 };
 MODULE_DEVICE_TABLE (pci, iTCO_wdt_pci_tbl);
@@ -355,7 +368,8 @@ static int iTCO_wdt_get_timeleft (int *time_left)
                spin_unlock(&iTCO_wdt_private.io_lock);
                *time_left = (val8 * 6) / 10;
-        }
+        } else
+                return -EINVAL;
        return 0;
 }
@@ -426,7 +440,6 @@ static int iTCO_wdt_ioctl (struct inode *inode, struct file *file,
 {
        int new_options, retval = -EINVAL;
        int new_heartbeat;
-        int time_left;
        void __user *argp = (void __user *)arg;
        int __user *p = argp;
        static struct watchdog_info ident = {
@@ -486,6 +499,8 @@ static int iTCO_wdt_ioctl (struct inode *inode, struct file *file,
                case WDIOC_GETTIMELEFT:
                {
+                        int time_left;
                        if (iTCO_wdt_get_timeleft(&time_left))
                                return -EINVAL;
diff --git a/drivers/char/watchdog/s3c2410_wdt.c b/drivers/char/watchdog/s3c2410_wdt.c
index 68b1ca976d53..18cb050c3862 100644
--- a/drivers/char/watchdog/s3c2410_wdt.c
+++ b/drivers/char/watchdog/s3c2410_wdt.c
@@ -380,18 +380,21 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
        if (res == NULL) {
                printk(KERN_INFO PFX "failed to get irq resource\n");
+                iounmap(wdt_base);
                return -ENOENT;
        }
        ret = request_irq(res->start, s3c2410wdt_irq, 0, pdev->name, pdev);
        if (ret != 0) {
                printk(KERN_INFO PFX "failed to install irq (%d)\n", ret);
+                iounmap(wdt_base);
                return ret;
        }
        wdt_clock = clk_get(&pdev->dev, "watchdog");
        if (wdt_clock == NULL) {
                printk(KERN_INFO PFX "failed to find watchdog clock source\n");
+                iounmap(wdt_base);
                return -ENOENT;
        }
@@ -415,6 +418,7 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
        if (ret) {
                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (%d)\n",
                        WATCHDOG_MINOR, ret);
+                iounmap(wdt_base);
                return ret;
        }
@@ -451,6 +455,7 @@ static int s3c2410wdt_remove(struct platform_device *dev)
                wdt_clock = NULL;
        }
+        iounmap(wdt_base);
        misc_deregister(&s3c2410wdt_miscdev);
        return 0;
 }
diff --git a/drivers/char/watchdog/smsc37b787_wdt.c b/drivers/char/watchdog/smsc37b787_wdt.c
new file mode 100644
index 000000000000..9f56913b484f
--- /dev/null
+++ b/drivers/char/watchdog/smsc37b787_wdt.c
@@ -0,0 +1,627 @@
+/*
+ *      SMsC 37B787 Watchdog Timer driver for Linux 2.6.x.x
+ *
+ *      Based on acquirewdt.c by Alan Cox <alan@redhat.com>
+ *       and some other existing drivers
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      The authors do NOT admit liability nor provide warranty for
+ *      any of this software. This material is provided "AS-IS" in
+ *      the hope that it may be useful for others.
+ *
+ *      (C) Copyright 2003-2006  Sven Anders <anders@anduras.de>
+ *
+ *  History:
+ *      2003 - Created version 1.0 for Linux 2.4.x.
+ *      2006 - Ported to Linux 2.6, added nowayout and MAGICCLOSE
+ *             features. Released version 1.1
+ *
+ *  Theory of operation:
+ *
+ *      A Watchdog Timer (WDT) is a hardware circuit that can
+ *      reset the computer system in case of a software fault.
+ *      You probably knew that already.
+ *
+ *      Usually a userspace daemon will notify the kernel WDT driver
+ *      via the /dev/watchdog special device file that userspace is
+ *      still alive, at regular intervals.  When such a notification
+ *      occurs, the driver will usually tell the hardware watchdog
+ *      that everything is in order, and that the watchdog should wait
+ *      for yet another little while to reset the system.
+ *      If userspace fails (RAM error, kernel bug, whatever), the
+ *      notifications cease to occur, and the hardware watchdog will
+ *      reset the system (causing a reboot) after the timeout occurs.
+ *
+ * Create device with:
+ *  mknod /dev/watchdog c 10 130
+ *
+ * For an example userspace keep-alive daemon, see:
+ *   Documentation/watchdog/watchdog.txt
+ */
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/ioport.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+/* enable support for minutes as units? */
+/* (does not always work correctly, so disabled by default!) */
+#define SMSC_SUPPORT_MINUTES
+#undef SMSC_SUPPORT_MINUTES
+#define MAX_TIMEOUT     255
+#define UNIT_SECOND     0
+#define UNIT_MINUTE     1
+#define MODNAME         "smsc37b787_wdt: "
+#define VERSION         "1.1"
+#define IOPORT          0x3F0
+#define IOPORT_SIZE     2
+#define IODEV_NO        8
+static int unit = UNIT_SECOND;  /* timer's unit */
+static int timeout = 60;        /* timeout value: default is 60 "units" */
+static unsigned long timer_enabled = 0;   /* is the timer enabled? */
+static char expect_close;       /* is the close expected? */
+static spinlock_t io_lock;      /* to guard the watchdog from io races */
+static int nowayout = WATCHDOG_NOWAYOUT;
+/* -- Low level function ----------------------------------------*/
+/* unlock the IO chip */
+static inline void open_io_config(void)
+{
+        outb(0x55, IOPORT);
+        mdelay(1);
+        outb(0x55, IOPORT);
+}
+/* lock the IO chip */
+static inline void close_io_config(void)
+{
+        outb(0xAA, IOPORT);
+}
+/* select the IO device */
+static inline void select_io_device(unsigned char devno)
+{
+        outb(0x07, IOPORT);
+        outb(devno, IOPORT+1);
+}
+/* write to the control register */
+static inline void write_io_cr(unsigned char reg, unsigned char data)
+{
+        outb(reg, IOPORT);
+        outb(data, IOPORT+1);
+}
+/* read from the control register */
+static inline char read_io_cr(unsigned char reg)
+{
+        outb(reg, IOPORT);
+        return inb(IOPORT+1);
+}
+/* -- Medium level functions ------------------------------------*/
+static inline void gpio_bit12(unsigned char reg)
+{
+        // -- General Purpose I/O Bit 1.2 --
+        // Bit 0,   In/Out: 0 = Output, 1 = Input
+        // Bit 1,   Polarity: 0 = No Invert, 1 = Invert
+        // Bit 2,   Group Enable Intr.: 0 = Disable, 1 = Enable
+        // Bit 3/4, Function select: 00 = GPI/O, 01 = WDT, 10 = P17,
+        //                           11 = Either Edge Triggered Intr. 2
+        // Bit 5/6  (Reserved)
+        // Bit 7,   Output Type: 0 = Push Pull Bit, 1 = Open Drain
+        write_io_cr(0xE2, reg);
+}
+static inline void gpio_bit13(unsigned char reg)
+{
+        // -- General Purpose I/O Bit 1.3 --
+        // Bit 0,  In/Out: 0 = Output, 1 = Input
+        // Bit 1,  Polarity: 0 = No Invert, 1 = Invert
+        // Bit 2,  Group Enable Intr.: 0 = Disable, 1 = Enable
+        // Bit 3,  Function select: 0 = GPI/O, 1 = LED
+        // Bit 4-6 (Reserved)
+        // Bit 7,  Output Type: 0 = Push Pull Bit, 1 = Open Drain
+        write_io_cr(0xE3, reg);
+}
+static inline void wdt_timer_units(unsigned char new_units)
+{
+        // -- Watchdog timer units --
+        // Bit 0-6 (Reserved)
+        // Bit 7,  WDT Time-out Value Units Select
+        //         (0 = Minutes, 1 = Seconds)
+        write_io_cr(0xF1, new_units);
+}
+static inline void wdt_timeout_value(unsigned char new_timeout)
+{
+        // -- Watchdog Timer Time-out Value --
+        // Bit 0-7 Binary coded units (0=Disabled, 1..255)
+        write_io_cr(0xF2, new_timeout);
+}
+static inline void wdt_timer_conf(unsigned char conf)
+{
+        // -- Watchdog timer configuration --
+        // Bit 0   Joystick enable: 0* = No Reset, 1 = Reset WDT upon Gameport I/O
+        // Bit 1   Keyboard enable: 0* = No Reset, 1 = Reset WDT upon KBD Intr.
+        // Bit 2   Mouse enable: 0* = No Reset, 1 = Reset WDT upon Mouse Intr.
+        // Bit 3   Reset the timer
+        //         (Wrong in SMsC documentation? Given as: PowerLED Timout Enabled)
+        // Bit 4-7 WDT Interrupt Mapping: (0000* = Disabled,
+        //            0001=IRQ1, 0010=(Invalid), 0011=IRQ3 to 1111=IRQ15)
+        write_io_cr(0xF3, conf);
+}
+static inline void wdt_timer_ctrl(unsigned char reg)
+{
+        // -- Watchdog timer control --
+        // Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
+        // Bit 1   Power LED Toggle: 0 = Disable Toggle, 1 = Toggle at 1 Hz
+        // Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
+        // Bit 3   P20 Force Timeout enabled:
+        //          0 = P20 activity does not generate the WD timeout event
+        //          1 = P20 Allows rising edge of P20, from the keyboard
+        //              controller, to force the WD timeout event.
+        // Bit 4   (Reserved)
+        // -- Soft power management --
+        // Bit 5   Stop Counter: 1 = Stop software power down counter
+        //            set via register 0xB8, (self-cleaning)
+        //            (Upon read: 0 = Counter running, 1 = Counter stopped)
+        // Bit 6   Restart Counter: 1 = Restart software power down counter
+        //            set via register 0xB8, (self-cleaning)
+        // Bit 7   SPOFF: 1 = Force software power down (self-cleaning)
+        write_io_cr(0xF4, reg);
+}
+/* -- Higher level functions ------------------------------------*/
+/* initialize watchdog */
+static void wb_smsc_wdt_initialize(void)
+{
+        unsigned char old;
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+        // enable the watchdog
+        gpio_bit13(0x08);  // Select pin 80 = LED not GPIO
+        gpio_bit12(0x0A);  // Set pin 79 = WDT not GPIO/Output/Polarity=Invert
+        // disable the timeout
+        wdt_timeout_value(0);
+        // reset control register
+        wdt_timer_ctrl(0x00);
+        // reset configuration register
+        wdt_timer_conf(0x00);
+        // read old (timer units) register
+        old = read_io_cr(0xF1) & 0x7F;
+        if (unit == UNIT_SECOND) old |= 0x80; // set to seconds
+        // set the watchdog timer units
+        wdt_timer_units(old);
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+/* shutdown the watchdog */
+static void wb_smsc_wdt_shutdown(void)
+{
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+        // disable the watchdog
+        gpio_bit13(0x09);
+        gpio_bit12(0x09);
+        // reset watchdog config register
+        wdt_timer_conf(0x00);
+        // reset watchdog control register
+        wdt_timer_ctrl(0x00);
+        // disable timeout
+        wdt_timeout_value(0x00);
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+/* set timeout => enable watchdog */
+static void wb_smsc_wdt_set_timeout(unsigned char new_timeout)
+{
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+        // set Power LED to blink, if we enable the timeout
+        wdt_timer_ctrl((new_timeout == 0) ? 0x00 : 0x02);
+        // set timeout value
+        wdt_timeout_value(new_timeout);
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+/* get timeout */
+static unsigned char wb_smsc_wdt_get_timeout(void)
+{
+        unsigned char set_timeout;
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+        set_timeout = read_io_cr(0xF2);
+        close_io_config();
+        spin_unlock(&io_lock);
+        return set_timeout;
+}
+/* disable watchdog */
+static void wb_smsc_wdt_disable(void)
+{
+        // set the timeout to 0 to disable the watchdog
+        wb_smsc_wdt_set_timeout(0);
+}
+/* enable watchdog by setting the current timeout */
+static void wb_smsc_wdt_enable(void)
+{
+        // set the current timeout...
+        wb_smsc_wdt_set_timeout(timeout);
+}
+/* reset the timer */
+static void wb_smsc_wdt_reset_timer(void)
+{
+        spin_lock(&io_lock);
+        open_io_config();
+        select_io_device(IODEV_NO);
+        // reset the timer
+        wdt_timeout_value(timeout);
+        wdt_timer_conf(0x08);
+        close_io_config();
+        spin_unlock(&io_lock);
+}
+/* return, if the watchdog is enabled (timeout is set...) */
+static int wb_smsc_wdt_status(void)
+{
+        return (wb_smsc_wdt_get_timeout() == 0) ? 0 : WDIOF_KEEPALIVEPING;
+}
+/* -- File operations -------------------------------------------*/
+/* open => enable watchdog and set initial timeout */
+static int wb_smsc_wdt_open(struct inode *inode, struct file *file)
+{
+        /* /dev/watchdog can only be opened once */
+        if (test_and_set_bit(0, &timer_enabled))
+                return -EBUSY;
+        if (nowayout)
+                __module_get(THIS_MODULE);
+        /* Reload and activate timer */
+        wb_smsc_wdt_enable();
+        printk(KERN_INFO MODNAME "Watchdog enabled. Timeout set to %d %s.\n", timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
+        return nonseekable_open(inode, file);
+}
+/* close => shut off the timer */
+static int wb_smsc_wdt_release(struct inode *inode, struct file *file)
+{
+        /* Shut off the timer. */
+        if (expect_close == 42) {
+                wb_smsc_wdt_disable();
+                printk(KERN_INFO MODNAME "Watchdog disabled, sleeping again...\n");
+        } else {
+                printk(KERN_CRIT MODNAME "Unexpected close, not stopping watchdog!\n");
+                wb_smsc_wdt_reset_timer();
+        }
+        clear_bit(0, &timer_enabled);
+        expect_close = 0;
+        return 0;
+}
+/* write => update the timer to keep the machine alive */
+static ssize_t wb_smsc_wdt_write(struct file *file, const char __user *data,
+                                 size_t len, loff_t *ppos)
+{
+        /* See if we got the magic character 'V' and reload the timer */
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+                        /* reset expect flag */
+                        expect_close = 0;
+                        /* scan to see whether or not we got the magic character */
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data+i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_close = 42;
+                        }
+                }
+                /* someone wrote to us, we should reload the timer */
+                wb_smsc_wdt_reset_timer();
+        }
+        return len;
+}
+/* ioctl => control interface */
+static int wb_smsc_wdt_ioctl(struct inode *inode, struct file *file,
+                             unsigned int cmd, unsigned long arg)
+{
+        int new_timeout;
+        union {
+                struct watchdog_info __user *ident;
+                int __user *i;
+        } uarg;
+        static struct watchdog_info ident = {
+                .options =              WDIOF_KEEPALIVEPING |
+                                        WDIOF_SETTIMEOUT |
+                                        WDIOF_MAGICCLOSE,
+                .firmware_version =     0,
+                .identity =             "SMsC 37B787 Watchdog"
+        };
+        uarg.i = (int __user *)arg;
+        switch (cmd) {
+                default:
+                        return -ENOTTY;
+                case WDIOC_GETSUPPORT:
+                        return copy_to_user(uarg.ident, &ident,
+                                sizeof(ident)) ? -EFAULT : 0;
+                case WDIOC_GETSTATUS:
+                        return put_user(wb_smsc_wdt_status(), uarg.i);
+                case WDIOC_GETBOOTSTATUS:
+                        return put_user(0, uarg.i);
+                case WDIOC_KEEPALIVE:
+                        wb_smsc_wdt_reset_timer();
+                        return 0;
+                case WDIOC_SETTIMEOUT:
+                        if (get_user(new_timeout, uarg.i))
+                                return -EFAULT;
+                        // the API states this is given in secs
+                        if (unit == UNIT_MINUTE)
+                          new_timeout /= 60;
+                        if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
+                                return -EINVAL;
+                        timeout = new_timeout;
+                        wb_smsc_wdt_set_timeout(timeout);
+                        // fall through and return the new timeout...
+                case WDIOC_GETTIMEOUT:
+                        new_timeout = timeout;
+                        if (unit == UNIT_MINUTE)
+                          new_timeout *= 60;
+                        return put_user(new_timeout, uarg.i);
+                case WDIOC_SETOPTIONS:
+                {
+                        int options, retval = -EINVAL;
+                        if (get_user(options, uarg.i))
+                                return -EFAULT;
+                        if (options & WDIOS_DISABLECARD) {
+                                wb_smsc_wdt_disable();
+                                retval = 0;
+                        }
+                        if (options & WDIOS_ENABLECARD) {
+                                wb_smsc_wdt_enable();
+                                retval = 0;
+                        }
+                        return retval;
+                }
+        }
+}
+/* -- Notifier funtions -----------------------------------------*/
+static int wb_smsc_wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+        {
+                // set timeout to 0, to avoid possible race-condition
+                timeout = 0;
+                wb_smsc_wdt_disable();
+        }
+        return NOTIFY_DONE;
+}
+/* -- Module's structures ---------------------------------------*/
+static struct file_operations wb_smsc_wdt_fops =
+{
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = wb_smsc_wdt_write,
+        .ioctl          = wb_smsc_wdt_ioctl,
+        .open           = wb_smsc_wdt_open,
+        .release        = wb_smsc_wdt_release,
+};
+static struct notifier_block wb_smsc_wdt_notifier =
+{
+        .notifier_call  = wb_smsc_wdt_notify_sys,
+};
+static struct miscdevice wb_smsc_wdt_miscdev =
+{
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &wb_smsc_wdt_fops,
+};
+/* -- Module init functions -------------------------------------*/
+/* module's "constructor" */
+static int __init wb_smsc_wdt_init(void)
+{
+        int ret;
+        spin_lock_init(&io_lock);
+        printk("SMsC 37B787 watchdog component driver " VERSION " initialising...\n");
+        if (!request_region(IOPORT, IOPORT_SIZE, "SMsC 37B787 watchdog")) {
+                printk(KERN_ERR MODNAME "Unable to register IO port %#x\n", IOPORT);
+                ret = -EBUSY;
+                goto out_pnp;
+        }
+        // set new maximum, if it's too big
+        if (timeout > MAX_TIMEOUT)
+               timeout = MAX_TIMEOUT;
+        // init the watchdog timer
+        wb_smsc_wdt_initialize();
+        ret = register_reboot_notifier(&wb_smsc_wdt_notifier);
+        if (ret) {
+                printk(KERN_ERR MODNAME "Unable to register reboot notifier err = %d\n", ret);
+                goto out_io;
+        }
+        ret = misc_register(&wb_smsc_wdt_miscdev);
+        if (ret) {
+                printk(KERN_ERR MODNAME "Unable to register miscdev on minor %d\n", WATCHDOG_MINOR);
+                goto out_rbt;
+        }
+        // output info
+        printk(KERN_INFO MODNAME "Timeout set to %d %s.\n", timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
+        printk(KERN_INFO MODNAME "Watchdog initialized and sleeping (nowayout=%d)...\n", nowayout);
+        // ret = 0
+out_clean:
+        return ret;
+out_rbt:
+        unregister_reboot_notifier(&wb_smsc_wdt_notifier);
+out_io:
+        release_region(IOPORT, IOPORT_SIZE);
+out_pnp:
+        goto out_clean;
+}
+/* module's "destructor" */
+static void __exit wb_smsc_wdt_exit(void)
+{
+        /* Stop the timer before we leave */
+        if (!nowayout)
+        {
+                wb_smsc_wdt_shutdown();
+                printk(KERN_INFO MODNAME "Watchdog disabled.\n");
+        }
+        misc_deregister(&wb_smsc_wdt_miscdev);
+        unregister_reboot_notifier(&wb_smsc_wdt_notifier);
+        release_region(IOPORT, IOPORT_SIZE);
+        printk("SMsC 37B787 watchdog component driver removed.\n");
+}
+module_init(wb_smsc_wdt_init);
+module_exit(wb_smsc_wdt_exit);
+MODULE_AUTHOR("Sven Anders <anders@anduras.de>");
+MODULE_DESCRIPTION("Driver for SMsC 37B787 watchdog component (Version " VERSION ")");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+#ifdef SMSC_SUPPORT_MINUTES
+module_param(unit, int, 0);
+MODULE_PARM_DESC(unit, "set unit to use, 0=seconds or 1=minutes, default is 0");
+#endif
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout, "range is 1-255 units, default is 60");
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
diff --git a/drivers/char/watchdog/w83627hf_wdt.c b/drivers/char/watchdog/w83627hf_wdt.c
index b4adc527e687..07d4bff27226 100644
--- a/drivers/char/watchdog/w83627hf_wdt.c
+++ b/drivers/char/watchdog/w83627hf_wdt.c
@@ -33,6 +33,7 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/spinlock.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -44,6 +45,7 @@
 static unsigned long wdt_is_open;
 static char expect_close;
+static spinlock_t io_lock;
 /* You must set this - there is no sane way to probe for this board. */
 static int wdt_io = 0x2E;
@@ -110,12 +112,16 @@ w83627hf_init(void)
 static void
 wdt_ctrl(int timeout)
 {
+        spin_lock(&io_lock);
+        
        w83627hf_select_wd_register();
        outb_p(0xF6, WDT_EFER);    /* Select CRF6 */
        outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF6 */
        w83627hf_unselect_wd_register();
+        spin_unlock(&io_lock);
 }
 static int
@@ -303,6 +309,8 @@ wdt_init(void)
 {
        int ret;
+        spin_lock_init(&io_lock);
        printk(KERN_INFO "WDT driver for the Winbond(TM) W83627HF Super I/O chip initialising.\n");
        if (wdt_set_heartbeat(timeout)) {
diff --git a/drivers/char/watchdog/w83697hf_wdt.c b/drivers/char/watchdog/w83697hf_wdt.c
new file mode 100644
index 000000000000..7768b55487c8
--- /dev/null
+++ b/drivers/char/watchdog/w83697hf_wdt.c
@@ -0,0 +1,450 @@
+/*
+ *      w83697hf/hg WDT driver
+ *
+ *      (c) Copyright 2006 Samuel Tardieu <sam@rfc1149.net>
+ *      (c) Copyright 2006 Marcus Junker <junker@anduras.de>
+ *
+ *      Based on w83627hf_wdt.c which is based on advantechwdt.c
+ *      which is based on wdt.c.
+ *      Original copyright messages:
+ *
+ *      (c) Copyright 2003 P�draig Brady <P@draigBrady.com>
+ *
+ *      (c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl>
+ *
+ *      (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
+ *                              http://www.redhat.com
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *      Neither Marcus Junker nor ANDURAS AG admit liability nor provide
+ *      warranty for any of this software. This material is provided
+ *      "AS-IS" and at no charge.
+ */
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/fs.h>
+#include <linux/ioport.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+#define WATCHDOG_NAME "w83697hf/hg WDT"
+#define PFX WATCHDOG_NAME ": "
+#define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
+static unsigned long wdt_is_open;
+static char expect_close;
+static spinlock_t io_lock;
+/* You must set this - there is no sane way to probe for this board. */
+static int wdt_io = 0x2e;
+module_param(wdt_io, int, 0);
+MODULE_PARM_DESC(wdt_io, "w83697hf/hg WDT io port (default 0x2e, 0 = autodetect)");
+static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=255, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
+/*
+ *      Kernel methods.
+ */
+#define W83697HF_EFER (wdt_io+0)        /* Extended Function Enable Register */
+#define W83697HF_EFIR (wdt_io+0)        /* Extended Function Index Register (same as EFER) */
+#define W83697HF_EFDR (wdt_io+1)        /* Extended Function Data Register */
+static inline void
+w83697hf_unlock(void)
+{
+        outb_p(0x87, W83697HF_EFER);    /* Enter extended function mode */
+        outb_p(0x87, W83697HF_EFER);    /* Again according to manual */
+}
+static inline void
+w83697hf_lock(void)
+{
+        outb_p(0xAA, W83697HF_EFER);    /* Leave extended function mode */
+}
+/*
+ *      The three functions w83697hf_get_reg(), w83697hf_set_reg() and
+ *      w83697hf_write_timeout() must be called with the device unlocked.
+ */
+static unsigned char
+w83697hf_get_reg(unsigned char reg)
+{
+        outb_p(reg, W83697HF_EFIR);
+        return inb_p(W83697HF_EFDR);
+}
+static void
+w83697hf_set_reg(unsigned char reg, unsigned char data)
+{
+        outb_p(reg, W83697HF_EFIR);
+        outb_p(data, W83697HF_EFDR);
+}
+static void
+w83697hf_write_timeout(int timeout)
+{
+        w83697hf_set_reg(0xF4, timeout);        /* Write Timeout counter to CRF4 */
+}
+static void
+w83697hf_select_wdt(void)
+{
+        w83697hf_unlock();
+        w83697hf_set_reg(0x07, 0x08);   /* Switch to logic device 8 (GPIO2) */
+}
+static inline void
+w83697hf_deselect_wdt(void)
+{
+        w83697hf_lock();
+}
+static void
+w83697hf_init(void)
+{
+        unsigned char bbuf;
+        w83697hf_select_wdt();
+        bbuf = w83697hf_get_reg(0x29);
+        bbuf &= ~0x60;
+        bbuf |= 0x20;
+        w83697hf_set_reg(0x29, bbuf);   /* Set pin 119 to WDTO# mode (= CR29, WDT0) */
+        bbuf = w83697hf_get_reg(0xF3);
+        bbuf &= ~0x04;
+        w83697hf_set_reg(0xF3, bbuf);   /* Count mode is seconds */
+        w83697hf_deselect_wdt();
+}
+static int
+wdt_ping(void)
+{
+        spin_lock(&io_lock);
+        w83697hf_select_wdt();
+        w83697hf_write_timeout(timeout);
+        w83697hf_deselect_wdt();
+        spin_unlock(&io_lock);
+        return 0;
+}
+static int
+wdt_enable(void)
+{
+        spin_lock(&io_lock);
+        w83697hf_select_wdt();
+        w83697hf_write_timeout(timeout);
+        w83697hf_set_reg(0x30, 1);      /* Enable timer */
+        w83697hf_deselect_wdt();
+        spin_unlock(&io_lock);
+        return 0;
+}
+static int
+wdt_disable(void)
+{
+        spin_lock(&io_lock);
+        w83697hf_select_wdt();
+        w83697hf_set_reg(0x30, 0);      /* Disable timer */
+        w83697hf_write_timeout(0);
+        w83697hf_deselect_wdt();
+        spin_unlock(&io_lock);
+        return 0;
+}
+static int
+wdt_set_heartbeat(int t)
+{
+        if ((t < 1) || (t > 255))
+                return -EINVAL;
+        timeout = t;
+        return 0;
+}
+static ssize_t
+wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+        if (count) {
+                if (!nowayout) {
+                        size_t i;
+                        expect_close = 0;
+                        for (i = 0; i != count; i++) {
+                                char c;
+                                if (get_user(c, buf+i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_close = 42;
+                        }
+                }
+                wdt_ping();
+        }
+        return count;
+}
+static int
+wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+          unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        int new_timeout;
+        static struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+                .firmware_version = 1,
+                .identity = "W83697HF WDT",
+        };
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_KEEPALIVE:
+                wdt_ping();
+                break;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (wdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+                wdt_ping();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        case WDIOC_SETOPTIONS:
+        {
+                int options, retval = -EINVAL;
+                if (get_user(options, p))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        wdt_disable();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        wdt_enable();
+                        retval = 0;
+                }
+                return retval;
+        }
+        default:
+                return -ENOTTY;
+        }
+        return 0;
+}
+static int
+wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(0, &wdt_is_open))
+                return -EBUSY;
+        /*
+         *      Activate
+         */
+        wdt_enable();
+        return nonseekable_open(inode, file);
+}
+static int
+wdt_close(struct inode *inode, struct file *file)
+{
+        if (expect_close == 42) {
+                wdt_disable();
+        } else {
+                printk (KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                wdt_ping();
+        }
+        expect_close = 0;
+        clear_bit(0, &wdt_is_open);
+        return 0;
+}
+/*
+ *      Notifier for system down
+ */
+static int
+wdt_notify_sys(struct notifier_block *this, unsigned long code,
+        void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT) {
+                /* Turn the WDT off */
+                wdt_disable();
+        }
+        return NOTIFY_DONE;
+}
+/*
+ *      Kernel Interfaces
+ */
+static struct file_operations wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = wdt_write,
+        .ioctl          = wdt_ioctl,
+        .open           = wdt_open,
+        .release        = wdt_close,
+};
+static struct miscdevice wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &wdt_fops,
+};
+/*
+ *      The WDT needs to learn about soft shutdowns in order to
+ *      turn the timebomb registers off.
+ */
+static struct notifier_block wdt_notifier = {
+        .notifier_call = wdt_notify_sys,
+};
+static int
+w83697hf_check_wdt(void)
+{
+        if (!request_region(wdt_io, 2, WATCHDOG_NAME)) {
+                printk (KERN_ERR PFX "I/O address 0x%x already in use\n", wdt_io);
+                return -EIO;
+        }
+        printk (KERN_DEBUG PFX "Looking for watchdog at address 0x%x\n", wdt_io);
+        w83697hf_unlock();
+        if (w83697hf_get_reg(0x20) == 0x60) {
+                printk (KERN_INFO PFX "watchdog found at address 0x%x\n", wdt_io);
+                w83697hf_lock();
+                return 0;
+        }
+        w83697hf_lock();        /* Reprotect in case it was a compatible device */
+        printk (KERN_INFO PFX "watchdog not found at address 0x%x\n", wdt_io);
+        release_region(wdt_io, 2);
+        return -EIO;
+}
+static int w83697hf_ioports[] = { 0x2e, 0x4e, 0x00 };
+static int __init
+wdt_init(void)
+{
+        int ret, i, found = 0;
+        spin_lock_init(&io_lock);
+        printk (KERN_INFO PFX "WDT driver for W83697HF/HG initializing\n");
+        if (wdt_io == 0) {
+                /* we will autodetect the W83697HF/HG watchdog */
+                for (i = 0; ((!found) && (w83697hf_ioports[i] != 0)); i++) {
+                        wdt_io = w83697hf_ioports[i];
+                        if (!w83697hf_check_wdt())
+                                found++;
+                }
+        } else {
+                if (!w83697hf_check_wdt())
+                        found++;
+        }
+        if (!found) {
+                printk (KERN_ERR PFX "No W83697HF/HG could be found\n");
+                ret = -EIO;
+                goto out;
+        }
+        w83697hf_init();
+        wdt_disable();  /* Disable watchdog until first use */
+        if (wdt_set_heartbeat(timeout)) {
+                wdt_set_heartbeat(WATCHDOG_TIMEOUT);
+                printk (KERN_INFO PFX "timeout value must be 1<=timeout<=255, using %d\n",
+                        WATCHDOG_TIMEOUT);
+        }
+        ret = register_reboot_notifier(&wdt_notifier);
+        if (ret != 0) {
+                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
+                        ret);
+                goto unreg_regions;
+        }
+        ret = misc_register(&wdt_miscdev);
+        if (ret != 0) {
+                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
+                        WATCHDOG_MINOR, ret);
+                goto unreg_reboot;
+        }
+        printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
+                timeout, nowayout);
+out:
+        return ret;
+unreg_reboot:
+        unregister_reboot_notifier(&wdt_notifier);
+unreg_regions:
+        release_region(wdt_io, 2);
+        goto out;
+}
+static void __exit
+wdt_exit(void)
+{
+        misc_deregister(&wdt_miscdev);
+        unregister_reboot_notifier(&wdt_notifier);
+        release_region(wdt_io, 2);
+}
+module_init(wdt_init);
+module_exit(wdt_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Marcus Junker <junker@anduras.de>, Samuel Tardieu <sam@rfc1149.net>");
+MODULE_DESCRIPTION("w83697hf/hg WDT driver");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/clocksource/acpi_pm.c b/drivers/clocksource/acpi_pm.c
index 7ad3be8c0f49..7fcb77a9d011 100644
--- a/drivers/clocksource/acpi_pm.c
+++ b/drivers/clocksource/acpi_pm.c
@@ -54,8 +54,8 @@ static cycle_t acpi_pm_read_verified(void)
                v1 = read_pmtmr();
                v2 = read_pmtmr();
                v3 = read_pmtmr();
-        } while ((v1 > v2 && v1 < v3) || (v2 > v3 && v2 < v1)
+        } while (unlikely((v1 > v2 && v1 < v3) || (v2 > v3 && v2 < v1)
-                        || (v3 > v1 && v3 < v2));
+                          || (v3 > v1 && v3 < v2)));
        return (cycle_t)v2;
 }
@@ -138,6 +138,8 @@ static void __devinit acpi_pm_check_graylist(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0,
                        acpi_pm_check_graylist);
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_LE,
+                        acpi_pm_check_graylist);
 #endif
diff --git a/drivers/fc4/fc.c b/drivers/fc4/fc.c
index 22d17474755f..ca4e67a022d0 100644
--- a/drivers/fc4/fc.c
+++ b/drivers/fc4/fc.c
@@ -70,9 +70,9 @@
 #define FCP_CMND(SCpnt) ((fcp_cmnd *)&(SCpnt->SCp))
 #define FC_SCMND(SCpnt) ((fc_channel *)(SCpnt->device->host->hostdata[0]))
-#define SC_FCMND(fcmnd) ((Scsi_Cmnd *)((long)fcmnd - (long)&(((Scsi_Cmnd *)0)->SCp)))
+#define SC_FCMND(fcmnd) ((struct scsi_cmnd *)((long)fcmnd - (long)&(((struct scsi_cmnd *)0)->SCp)))
-static int fcp_scsi_queue_it(fc_channel *, Scsi_Cmnd *, fcp_cmnd *, int);
+static int fcp_scsi_queue_it(fc_channel *, struct scsi_cmnd *, fcp_cmnd *, int);
 void fcp_queue_empty(fc_channel *);
 static void fcp_scsi_insert_queue (fc_channel *fc, fcp_cmnd *fcmd)
@@ -378,14 +378,14 @@ void fcp_register(fc_channel *fc, u8 type, int unregister)
                printk ("FC: %segistering unknown type %02x\n", unregister ? "Unr" : "R", type);
 }
-static void fcp_scsi_done(Scsi_Cmnd *SCpnt);
+static void fcp_scsi_done(struct scsi_cmnd *SCpnt);
 static inline void fcp_scsi_receive(fc_channel *fc, int token, int status, fc_hdr *fch)
 {
        fcp_cmnd *fcmd;
        fcp_rsp  *rsp;
        int host_status;
-        Scsi_Cmnd *SCpnt;
+        struct scsi_cmnd *SCpnt;
        int sense_len;
        int rsp_status;
@@ -757,13 +757,14 @@ void fcp_release(fc_channel *fcchain, int count)  /* count must > 0 */
 }
-static void fcp_scsi_done (Scsi_Cmnd *SCpnt)
+static void fcp_scsi_done(struct scsi_cmnd *SCpnt)
 {
        if (FCP_CMND(SCpnt)->done)
                FCP_CMND(SCpnt)->done(SCpnt);
 }
-static int fcp_scsi_queue_it(fc_channel *fc, Scsi_Cmnd *SCpnt, fcp_cmnd *fcmd, int prepare)
+static int fcp_scsi_queue_it(fc_channel *fc, struct scsi_cmnd *SCpnt,
+                             fcp_cmnd *fcmd, int prepare)
 {
        long i;
        fcp_cmd *cmd;
@@ -837,7 +838,8 @@ static int fcp_scsi_queue_it(fc_channel *fc, Scsi_Cmnd *SCpnt, fcp_cmnd *fcmd, i
        return 0;
 }
-int fcp_scsi_queuecommand(Scsi_Cmnd *SCpnt, void (* done)(Scsi_Cmnd *))
+int fcp_scsi_queuecommand(struct scsi_cmnd *SCpnt,
+                          void (* done)(struct scsi_cmnd *))
 {
        fcp_cmnd *fcmd = FCP_CMND(SCpnt);
        fc_channel *fc = FC_SCMND(SCpnt);
@@ -873,7 +875,7 @@ void fcp_queue_empty(fc_channel *fc)
        }
 }
-int fcp_scsi_abort(Scsi_Cmnd *SCpnt)
+int fcp_scsi_abort(struct scsi_cmnd *SCpnt)
 {
        /* Internal bookkeeping only. Lose 1 cmd_slots slot. */
        fcp_cmnd *fcmd = FCP_CMND(SCpnt);
@@ -910,7 +912,7 @@ int fcp_scsi_abort(Scsi_Cmnd *SCpnt)
 }
 #if 0
-void fcp_scsi_reset_done(Scsi_Cmnd *SCpnt)
+void fcp_scsi_reset_done(struct scsi_cmnd *SCpnt)
 {
        fc_channel *fc = FC_SCMND(SCpnt);
@@ -921,7 +923,7 @@ void fcp_scsi_reset_done(Scsi_Cmnd *SCpnt)
 #define FCP_RESET_TIMEOUT (2*HZ)
-int fcp_scsi_dev_reset(Scsi_Cmnd *SCpnt)
+int fcp_scsi_dev_reset(struct scsi_cmnd *SCpnt)
 {
 #if 0 /* broken junk, but if davem wants to compile this driver, let him.. */
        unsigned long flags;
@@ -931,7 +933,7 @@ int fcp_scsi_dev_reset(Scsi_Cmnd *SCpnt)
        DECLARE_MUTEX_LOCKED(sem);
        if (!fc->rst_pkt) {
-                fc->rst_pkt = (Scsi_Cmnd *) kmalloc(sizeof(SCpnt), GFP_KERNEL);
+                fc->rst_pkt = (struct scsi_cmnd *) kmalloc(sizeof(SCpnt), GFP_KERNEL);
                if (!fc->rst_pkt) return FAILED;
                
                fcmd = FCP_CMND(fc->rst_pkt);
@@ -999,7 +1001,7 @@ int fcp_scsi_dev_reset(Scsi_Cmnd *SCpnt)
        return SUCCESS;
 }
-static int __fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
+static int __fcp_scsi_host_reset(struct scsi_cmnd *SCpnt)
 {
        fc_channel *fc = FC_SCMND(SCpnt);
        fcp_cmnd *fcmd = FCP_CMND(SCpnt);
@@ -1020,7 +1022,7 @@ static int __fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
        else return FAILED;
 }
-int fcp_scsi_host_reset(Scsi_Cmnd *SCpnt)
+int fcp_scsi_host_reset(struct scsi_cmnd *SCpnt)
 {
        unsigned long flags;
        int rc;
diff --git a/drivers/fc4/fcp_impl.h b/drivers/fc4/fcp_impl.h
index c397c84bef63..1ac61330592e 100644
--- a/drivers/fc4/fcp_impl.h
+++ b/drivers/fc4/fcp_impl.h
@@ -39,7 +39,7 @@ struct _fc_channel;
 typedef struct fcp_cmnd {
        struct fcp_cmnd         *next;
        struct fcp_cmnd         *prev;
-        void                    (*done)(Scsi_Cmnd *);
+        void                    (*done)(struct scsi_cmnd *);
        unsigned short          proto;
        unsigned short          token;
        unsigned int            did;
@@ -94,14 +94,14 @@ typedef struct _fc_channel {
        long                    *scsi_bitmap;
        long                    scsi_bitmap_end;
        int                     scsi_free;
-        int                     (*encode_addr)(Scsi_Cmnd *, u16 *, struct _fc_channel *, fcp_cmnd *);
+        int                     (*encode_addr)(struct scsi_cmnd *, u16 *, struct _fc_channel *, fcp_cmnd *);
        fcp_cmnd                *scsi_que;
        char                    scsi_name[4];
        fcp_cmnd                **cmd_slots;
        int                     channels;
        int                     targets;
        long                    *ages;
-        Scsi_Cmnd               *rst_pkt;
+        struct scsi_cmnd        *rst_pkt;
        fcp_posmap              *posmap;
        /* LOGIN stuff */
        fcp_cmnd                *login;
@@ -155,9 +155,10 @@ int fc_do_prli(fc_channel *, unsigned char);
        for_each_fc_channel(fc)                         \
                if (fc->state == FC_STATE_ONLINE)
-int fcp_scsi_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
+int fcp_scsi_queuecommand(struct scsi_cmnd *,
-int fcp_scsi_abort(Scsi_Cmnd *);
+                          void (* done) (struct scsi_cmnd *));
-int fcp_scsi_dev_reset(Scsi_Cmnd *);
+int fcp_scsi_abort(struct scsi_cmnd *);
-int fcp_scsi_host_reset(Scsi_Cmnd *);
+int fcp_scsi_dev_reset(struct scsi_cmnd *);
+int fcp_scsi_host_reset(struct scsi_cmnd *);
 #endif /* !(_FCP_SCSI_H) */
diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c
index b8b596d5778d..37deee6c0c1c 100644
--- a/drivers/firmware/dmi_scan.c
+++ b/drivers/firmware/dmi_scan.c
@@ -326,6 +326,26 @@ char *dmi_get_system_info(int field)
 }
 EXPORT_SYMBOL(dmi_get_system_info);
+/**
+ *      dmi_name_in_vendors - Check if string is anywhere in the DMI vendor information.
+ *      @str:   Case sensitive Name
+ */
+int dmi_name_in_vendors(char *str)
+{
+        static int fields[] = { DMI_BIOS_VENDOR, DMI_BIOS_VERSION, DMI_SYS_VENDOR,
+                                DMI_PRODUCT_NAME, DMI_PRODUCT_VERSION, DMI_BOARD_VENDOR,
+                                DMI_BOARD_NAME, DMI_BOARD_VERSION, DMI_NONE };
+        int i;
+        for (i = 0; fields[i] != DMI_NONE; i++) {
+                int f = fields[i];
+                if (dmi_ident[f] && strstr(dmi_ident[f], str))
+                        return 1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(dmi_name_in_vendors);
 /**
 *      dmi_find_device - find onboard device by type/name
 *      @type: device type or %DMI_DEV_TYPE_ANY to match all device types
diff --git a/drivers/ide/pci/generic.c b/drivers/ide/pci/generic.c
index 5b77a5bcbf0c..ad418ce882ca 100644
--- a/drivers/ide/pci/generic.c
+++ b/drivers/ide/pci/generic.c
@@ -40,6 +40,19 @@
 static int ide_generic_all;             /* Set to claim all devices */
+/*
+ * the module_param_named() was added for the modular case
+ * the __setup() is left as compatibility for existing setups
+ */
+#ifndef MODULE
+static int __init ide_generic_all_on(char *unused)
+{
+        ide_generic_all = 1;
+        printk(KERN_INFO "IDE generic will claim all unknown PCI IDE storage controllers.");
+        return 1;
+}
+__setup("all-generic-ide", ide_generic_all_on);
+#endif
 module_param_named(all_generic_ide, ide_generic_all, bool, 0444);
 MODULE_PARM_DESC(all_generic_ide, "IDE generic will claim all unknown PCI IDE storage controllers.");
diff --git a/drivers/input/touchscreen/hp680_ts_input.c b/drivers/input/touchscreen/hp680_ts_input.c
index e31c6c55b2e2..58fca316786c 100644
--- a/drivers/input/touchscreen/hp680_ts_input.c
+++ b/drivers/input/touchscreen/hp680_ts_input.c
@@ -6,7 +6,7 @@
 #include <asm/io.h>
 #include <asm/delay.h>
 #include <asm/adc.h>
-#include <asm/hp6xx/hp6xx.h>
+#include <asm/hp6xx.h>
 #define MODNAME "hp680_ts_input"
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index d47d38ac71b1..d6f614738bbd 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -536,7 +536,7 @@ static int bitmap_read_sb(struct bitmap *bitmap)
                printk(KERN_INFO "%s: bitmap file is out of date (%llu < %llu) "
                        "-- forcing full recovery\n", bmname(bitmap), events,
                        (unsigned long long) bitmap->mddev->events);
-                sb->state |= BITMAP_STALE;
+                sb->state |= cpu_to_le32(BITMAP_STALE);
        }
 success:
        /* assign fields using values from superblock */
@@ -544,11 +544,11 @@ success:
        bitmap->daemon_sleep = daemon_sleep;
        bitmap->daemon_lastrun = jiffies;
        bitmap->max_write_behind = write_behind;
-        bitmap->flags |= sb->state;
+        bitmap->flags |= le32_to_cpu(sb->state);
        if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)
                bitmap->flags |= BITMAP_HOSTENDIAN;
        bitmap->events_cleared = le64_to_cpu(sb->events_cleared);
-        if (sb->state & BITMAP_STALE)
+        if (sb->state & cpu_to_le32(BITMAP_STALE))
                bitmap->events_cleared = bitmap->mddev->events;
        err = 0;
 out:
@@ -578,9 +578,9 @@ static void bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
        spin_unlock_irqrestore(&bitmap->lock, flags);
        sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
        switch (op) {
-                case MASK_SET: sb->state |= bits;
+                case MASK_SET: sb->state |= cpu_to_le32(bits);
                                break;
-                case MASK_UNSET: sb->state &= ~bits;
+                case MASK_UNSET: sb->state &= cpu_to_le32(~bits);
                                break;
                default: BUG();
        }
diff --git a/drivers/md/md.c b/drivers/md/md.c
index f7f19088f3be..7daa7b1e145f 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -974,12 +974,13 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 * version 1 superblock
 */
-static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
+static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
 {
-        unsigned int disk_csum, csum;
+        __le32 disk_csum;
+        u32 csum;
        unsigned long long newcsum;
        int size = 256 + le32_to_cpu(sb->max_dev)*2;
-        unsigned int *isuper = (unsigned int*)sb;
+        __le32 *isuper = (__le32*)sb;
        int i;
        disk_csum = sb->sb_csum;
@@ -989,7 +990,7 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
                newcsum += le32_to_cpu(*isuper++);
        if (size == 2)
-                newcsum += le16_to_cpu(*(unsigned short*) isuper);
+                newcsum += le16_to_cpu(*(__le16*) isuper);
        csum = (newcsum & 0xffffffff) + (newcsum >> 32);
        sb->sb_csum = disk_csum;
@@ -1106,7 +1107,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
        if (le32_to_cpu(sb->chunksize))
                rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
-        if (le32_to_cpu(sb->size) > rdev->size*2)
+        if (le64_to_cpu(sb->size) > rdev->size*2)
                return -EINVAL;
        return ret;
 }
@@ -1228,7 +1229,7 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
        else
                sb->resync_offset = cpu_to_le64(0);
-        sb->cnt_corrected_read = atomic_read(&rdev->corrected_errors);
+        sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
        sb->raid_disks = cpu_to_le32(mddev->raid_disks);
        sb->size = cpu_to_le64(mddev->size<<1);
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 171ff41b52b0..a6260f0e3b9e 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -501,7 +501,7 @@ static int multipath_run (mddev_t *mddev)
                        mdname(mddev));
                goto out_free_conf;
        }
-        mddev->degraded = conf->raid_disks = conf->working_disks;
+        mddev->degraded = conf->raid_disks - conf->working_disks;
        conf->pool = mempool_create_kzalloc_pool(NR_RESERVED_BUFS,
                                                 sizeof(struct multipath_bh));
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 1250f0eab4af..74f17a9a6ebb 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -2079,7 +2079,7 @@ static int run(mddev_t *mddev)
                disk = conf->mirrors + i;
                if (!disk->rdev ||
-                    !test_bit(In_sync, &rdev->flags)) {
+                    !test_bit(In_sync, &disk->rdev->flags)) {
                        disk->head_position = 0;
                        mddev->degraded++;
                }
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index c537d71c18e4..a4afad4ecab2 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -75,8 +75,8 @@
 #define COPYRIGHT       "Copyright (c) 1999-2005 " MODULEAUTHOR
 #endif
-#define MPT_LINUX_VERSION_COMMON        "3.04.01"
+#define MPT_LINUX_VERSION_COMMON        "3.04.02"
-#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.01"
+#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.02"
 #define WHAT_MAGIC_STRING               "@" "(" "#" ")"
 #define show_mptmod_ver(s,ver)  \
diff --git a/drivers/message/fusion/mptfc.c b/drivers/message/fusion/mptfc.c
index e57bb035a021..1dd491773150 100644
--- a/drivers/message/fusion/mptfc.c
+++ b/drivers/message/fusion/mptfc.c
@@ -96,6 +96,10 @@ static int mptfc_qcmd(struct scsi_cmnd *SCpnt,
 static void mptfc_target_destroy(struct scsi_target *starget);
 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
 static void __devexit mptfc_remove(struct pci_dev *pdev);
+static int mptfc_abort(struct scsi_cmnd *SCpnt);
+static int mptfc_dev_reset(struct scsi_cmnd *SCpnt);
+static int mptfc_bus_reset(struct scsi_cmnd *SCpnt);
+static int mptfc_host_reset(struct scsi_cmnd *SCpnt);
 static struct scsi_host_template mptfc_driver_template = {
        .module                         = THIS_MODULE,
@@ -110,10 +114,10 @@ static struct scsi_host_template mptfc_driver_template = {
        .target_destroy                 = mptfc_target_destroy,
        .slave_destroy                  = mptscsih_slave_destroy,
        .change_queue_depth             = mptscsih_change_queue_depth,
-        .eh_abort_handler               = mptscsih_abort,
+        .eh_abort_handler               = mptfc_abort,
-        .eh_device_reset_handler        = mptscsih_dev_reset,
+        .eh_device_reset_handler        = mptfc_dev_reset,
-        .eh_bus_reset_handler           = mptscsih_bus_reset,
+        .eh_bus_reset_handler           = mptfc_bus_reset,
-        .eh_host_reset_handler          = mptscsih_host_reset,
+        .eh_host_reset_handler          = mptfc_host_reset,
        .bios_param                     = mptscsih_bios_param,
        .can_queue                      = MPT_FC_CAN_QUEUE,
        .this_id                        = -1,
@@ -171,6 +175,77 @@ static struct fc_function_template mptfc_transport_functions = {
        .show_host_symbolic_name = 1,
 };
+static int
+mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
+                          int (*func)(struct scsi_cmnd *SCpnt),
+                          const char *caller)
+{
+        struct scsi_device      *sdev = SCpnt->device;
+        struct Scsi_Host        *shost = sdev->host;
+        struct fc_rport         *rport = starget_to_rport(scsi_target(sdev));
+        unsigned long           flags;
+        int                     ready;
+        spin_lock_irqsave(shost->host_lock, flags);
+        while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY) {
+                spin_unlock_irqrestore(shost->host_lock, flags);
+                dfcprintk ((MYIOC_s_INFO_FMT
+                        "mptfc_block_error_handler.%d: %d:%d, port status is "
+                        "DID_IMM_RETRY, deferring %s recovery.\n",
+                        ((MPT_SCSI_HOST *) shost->hostdata)->ioc->name,
+                        ((MPT_SCSI_HOST *) shost->hostdata)->ioc->sh->host_no,
+                        SCpnt->device->id,SCpnt->device->lun,caller));
+                msleep(1000);
+                spin_lock_irqsave(shost->host_lock, flags);
+        }
+        spin_unlock_irqrestore(shost->host_lock, flags);
+        if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata) {
+                dfcprintk ((MYIOC_s_INFO_FMT
+                        "%s.%d: %d:%d, failing recovery, "
+                        "port state %d, vdev %p.\n", caller,
+                        ((MPT_SCSI_HOST *) shost->hostdata)->ioc->name,
+                        ((MPT_SCSI_HOST *) shost->hostdata)->ioc->sh->host_no,
+                        SCpnt->device->id,SCpnt->device->lun,ready,
+                        SCpnt->device->hostdata));
+                return FAILED;
+        }
+        dfcprintk ((MYIOC_s_INFO_FMT
+                "%s.%d: %d:%d, executing recovery.\n", caller,
+                ((MPT_SCSI_HOST *) shost->hostdata)->ioc->name,
+                ((MPT_SCSI_HOST *) shost->hostdata)->ioc->sh->host_no,
+                SCpnt->device->id,SCpnt->device->lun));
+        return (*func)(SCpnt);
+}
+static int
+mptfc_abort(struct scsi_cmnd *SCpnt)
+{
+        return
+            mptfc_block_error_handler(SCpnt, mptscsih_abort, __FUNCTION__);
+}
+static int
+mptfc_dev_reset(struct scsi_cmnd *SCpnt)
+{
+        return
+            mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __FUNCTION__);
+}
+static int
+mptfc_bus_reset(struct scsi_cmnd *SCpnt)
+{
+        return
+            mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __FUNCTION__);
+}
+static int
+mptfc_host_reset(struct scsi_cmnd *SCpnt)
+{
+        return
+            mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __FUNCTION__);
+}
 static void
 mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 {
@@ -562,6 +637,12 @@ mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
                return 0;
        }
+        if (!SCpnt->device->hostdata) { /* vdev */
+                SCpnt->result = DID_NO_CONNECT << 16;
+                done(SCpnt);
+                return 0;
+        }
        /* dd_data is null until finished adding target */
        ri = *((struct mptfc_rport_info **)rport->dd_data);
        if (unlikely(!ri)) {
diff --git a/drivers/message/i2o/exec-osm.c b/drivers/message/i2o/exec-osm.c
index 91f95d172ca5..01a5a702b037 100644
--- a/drivers/message/i2o/exec-osm.c
+++ b/drivers/message/i2o/exec-osm.c
@@ -127,7 +127,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
        DECLARE_WAIT_QUEUE_HEAD(wq);
        struct i2o_exec_wait *wait;
        static u32 tcntxt = 0x80000000;
-        long flags;
+        unsigned long flags;
        int rc = 0;
        wait = i2o_exec_wait_alloc();
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index b6c045dc97b4..00db31c314e0 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -30,6 +30,7 @@ config IBM_ASM
 config SGI_IOC4
        tristate "SGI IOC4 Base IO support"
+        depends on PCI
        ---help---
          This option enables basic support for the IOC4 chip on certain
          SGI IO controller cards (IO9, IO10, and PCI-RT).  This option
diff --git a/drivers/misc/ioc4.c b/drivers/misc/ioc4.c
index 1c3c14a3839c..79354bbbbd6a 100644
--- a/drivers/misc/ioc4.c
+++ b/drivers/misc/ioc4.c
@@ -32,6 +32,7 @@
 #include <linux/ktime.h>
 #include <linux/mutex.h>
 #include <linux/time.h>
+#include <asm/io.h>
 /***************
 * Definitions *
diff --git a/drivers/mmc/tifm_sd.c b/drivers/mmc/tifm_sd.c
index 2bacff60913d..0fdc55b08a6d 100644
--- a/drivers/mmc/tifm_sd.c
+++ b/drivers/mmc/tifm_sd.c
@@ -14,6 +14,7 @@
 #include <linux/mmc/protocol.h>
 #include <linux/mmc/host.h>
 #include <linux/highmem.h>
+#include <asm/io.h>
 #define DRIVER_NAME "tifm_sd"
 #define DRIVER_VERSION "0.6"
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index e2ed24918a58..e38846eb51fa 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2717,6 +2717,7 @@ config PPP_MPPE
       select CRYPTO
       select CRYPTO_SHA1
       select CRYPTO_ARC4
+       select CRYPTO_ECB
       ---help---
         Support for the MPPE Encryption protocol, as employed by the
         Microsoft Point-to-Point Tunneling Protocol.
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_dma.h b/drivers/net/wireless/bcm43xx/bcm43xx_dma.h
index ea16078cfe98..d1105e569a41 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_dma.h
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_dma.h
@@ -4,6 +4,7 @@
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <linux/dma-mapping.h>
 #include <linux/linkage.h>
 #include <asm/atomic.h>
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index 8f882690994d..74c0eac083e4 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -107,6 +107,10 @@ zfcp_address_to_sg(void *address, struct scatterlist *list)
        (ZFCP_MAX_SBALS_PER_REQ * ZFCP_MAX_SBALES_PER_SBAL - 2)
        /* request ID + QTCB in SBALE 0 + 1 of first SBAL in chain */
+#define ZFCP_MAX_SECTORS (ZFCP_MAX_SBALES_PER_REQ * 8)
+        /* max. number of (data buffer) SBALEs in largest SBAL chain
+           multiplied with number of sectors per 4k block */
 /* FIXME(tune): free space should be one max. SBAL chain plus what? */
 #define ZFCP_QDIO_PCI_INTERVAL          (QDIO_MAX_BUFFERS_PER_Q \
                                         - (ZFCP_MAX_SBALS_PER_REQ + 4))
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 4d2bc7981324..452d96f92a14 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -58,6 +58,7 @@ struct zfcp_data zfcp_data = {
                .cmd_per_lun            = 1,
                .use_clustering         = 1,
                .sdev_attrs             = zfcp_sysfs_sdev_attrs,
+                .max_sectors            = ZFCP_MAX_SECTORS,
        },
        .driver_version = ZFCP_VERSION,
 };
diff --git a/drivers/scsi/aic7xxx/aic79xx.h b/drivers/scsi/aic7xxx/aic79xx.h
index df3346b5caf8..170a4344cbb2 100644
--- a/drivers/scsi/aic7xxx/aic79xx.h
+++ b/drivers/scsi/aic7xxx/aic79xx.h
@@ -53,14 +53,6 @@ struct ahd_platform_data;
 struct scb_platform_data;
 /****************************** Useful Macros *********************************/
-#ifndef MAX
-#define MAX(a,b) (((a) > (b)) ? (a) : (b))
-#endif
-#ifndef MIN
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
-#endif
 #ifndef TRUE
 #define TRUE 1
 #endif
@@ -972,8 +964,6 @@ int		ahd_read_seeprom(struct ahd_softc *ahd, uint16_t *buf,
 int             ahd_write_seeprom(struct ahd_softc *ahd, uint16_t *buf,
                                  u_int start_addr, u_int count);
-int             ahd_wait_seeprom(struct ahd_softc *ahd);
-int             ahd_verify_vpd_cksum(struct vpd_config *vpd);
 int             ahd_verify_cksum(struct seeprom_config *sc);
 int             ahd_acquire_seeprom(struct ahd_softc *ahd);
 void            ahd_release_seeprom(struct ahd_softc *ahd);
@@ -1320,8 +1310,6 @@ struct ahd_pci_identity {
        char                    *name;
        ahd_device_setup_t      *setup;
 };
-extern struct ahd_pci_identity ahd_pci_ident_table [];
-extern const u_int ahd_num_pci_devs;
 /***************************** VL/EISA Declarations ***************************/
 struct aic7770_identity {
@@ -1339,15 +1327,6 @@ extern const int ahd_num_aic7770_devs;
 /*************************** Function Declarations ****************************/
 /******************************************************************************/
 void                    ahd_reset_cmds_pending(struct ahd_softc *ahd);
-u_int                   ahd_find_busy_tcl(struct ahd_softc *ahd, u_int tcl);
-void                    ahd_busy_tcl(struct ahd_softc *ahd,
-                                     u_int tcl, u_int busyid);
-static __inline void    ahd_unbusy_tcl(struct ahd_softc *ahd, u_int tcl);
-static __inline void
-ahd_unbusy_tcl(struct ahd_softc *ahd, u_int tcl)
-{
-        ahd_busy_tcl(ahd, tcl, SCB_LIST_NULL);
-}
 /***************************** PCI Front End *********************************/
 struct  ahd_pci_identity *ahd_find_pci_device(ahd_dev_softc_t);
@@ -1356,7 +1335,6 @@ int			  ahd_pci_config(struct ahd_softc *,
 int     ahd_pci_test_register_access(struct ahd_softc *);
 /************************** SCB and SCB queue management **********************/
-int             ahd_probe_scbs(struct ahd_softc *);
 void            ahd_qinfifo_requeue_tail(struct ahd_softc *ahd,
                                         struct scb *scb);
 int             ahd_match_scb(struct ahd_softc *ahd, struct scb *scb,
@@ -1374,33 +1352,20 @@ int			 ahd_parse_vpddata(struct ahd_softc *ahd,
 int                      ahd_parse_cfgdata(struct ahd_softc *ahd,
                                           struct seeprom_config *sc);
 void                     ahd_intr_enable(struct ahd_softc *ahd, int enable);
-void                     ahd_update_coalescing_values(struct ahd_softc *ahd,
-                                                      u_int timer,
-                                                      u_int maxcmds,
-                                                      u_int mincmds);
-void                     ahd_enable_coalescing(struct ahd_softc *ahd,
-                                               int enable);
 void                     ahd_pause_and_flushwork(struct ahd_softc *ahd);
 int                      ahd_suspend(struct ahd_softc *ahd); 
-int                      ahd_resume(struct ahd_softc *ahd);
 void                     ahd_set_unit(struct ahd_softc *, int);
 void                     ahd_set_name(struct ahd_softc *, char *);
 struct scb              *ahd_get_scb(struct ahd_softc *ahd, u_int col_idx);
 void                     ahd_free_scb(struct ahd_softc *ahd, struct scb *scb);
-void                     ahd_alloc_scbs(struct ahd_softc *ahd);
 void                     ahd_free(struct ahd_softc *ahd);
 int                      ahd_reset(struct ahd_softc *ahd, int reinit);
-void                     ahd_shutdown(void *arg);
 int                      ahd_write_flexport(struct ahd_softc *ahd,
                                            u_int addr, u_int value);
 int                      ahd_read_flexport(struct ahd_softc *ahd, u_int addr,
                                           uint8_t *value);
-int                      ahd_wait_flexport(struct ahd_softc *ahd);
 /*************************** Interrupt Services *******************************/
-void                    ahd_pci_intr(struct ahd_softc *ahd);
-void                    ahd_clear_intstat(struct ahd_softc *ahd);
-void                    ahd_flush_qoutfifo(struct ahd_softc *ahd);
 void                    ahd_run_qoutfifo(struct ahd_softc *ahd);
 #ifdef AHD_TARGET_MODE
 void                    ahd_run_tqinfifo(struct ahd_softc *ahd, int paused);
@@ -1409,7 +1374,6 @@ void			ahd_handle_hwerrint(struct ahd_softc *ahd);
 void                    ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat);
 void                    ahd_handle_scsiint(struct ahd_softc *ahd,
                                           u_int intstat);
-void                    ahd_clear_critical_section(struct ahd_softc *ahd);
 /***************************** Error Recovery *********************************/
 typedef enum {
@@ -1426,23 +1390,9 @@ int			ahd_search_disc_list(struct ahd_softc *ahd, int target,
                                             char channel, int lun, u_int tag,
                                             int stop_on_first, int remove,
                                             int save_state);
-void                    ahd_freeze_devq(struct ahd_softc *ahd, struct scb *scb);
 int                     ahd_reset_channel(struct ahd_softc *ahd, char channel,
                                          int initiate_reset);
-int                     ahd_abort_scbs(struct ahd_softc *ahd, int target,
-                                       char channel, int lun, u_int tag,
-                                       role_t role, uint32_t status);
-void                    ahd_restart(struct ahd_softc *ahd);
-void                    ahd_clear_fifo(struct ahd_softc *ahd, u_int fifo);
-void                    ahd_handle_scb_status(struct ahd_softc *ahd,
-                                              struct scb *scb);
-void                    ahd_handle_scsi_status(struct ahd_softc *ahd,
-                                               struct scb *scb);
-void                    ahd_calc_residual(struct ahd_softc *ahd,
-                                          struct scb *scb);
 /*************************** Utility Functions ********************************/
-struct ahd_phase_table_entry*
-                        ahd_lookup_phase_entry(int phase);
 void                    ahd_compile_devinfo(struct ahd_devinfo *devinfo,
                                            u_int our_id, u_int target,
                                            u_int lun, char channel,
@@ -1450,14 +1400,6 @@ void			ahd_compile_devinfo(struct ahd_devinfo *devinfo,
 /************************** Transfer Negotiation ******************************/
 void                    ahd_find_syncrate(struct ahd_softc *ahd, u_int *period,
                                          u_int *ppr_options, u_int maxsync);
-void                    ahd_validate_offset(struct ahd_softc *ahd,
-                                            struct ahd_initiator_tinfo *tinfo,
-                                            u_int period, u_int *offset,
-                                            int wide, role_t role);
-void                    ahd_validate_width(struct ahd_softc *ahd,
-                                           struct ahd_initiator_tinfo *tinfo,
-                                           u_int *bus_width,
-                                           role_t role);
 /*
 * Negotiation types.  These are used to qualify if we should renegotiate
 * even if our goal and current transport parameters are identical.
@@ -1486,11 +1428,6 @@ typedef enum {
        AHD_QUEUE_TAGGED
 } ahd_queue_alg;
-void                    ahd_set_tags(struct ahd_softc *ahd,
-                                     struct scsi_cmnd *cmd,
-                                     struct ahd_devinfo *devinfo,
-                                     ahd_queue_alg alg);
 /**************************** Target Mode *************************************/
 #ifdef AHD_TARGET_MODE
 void            ahd_send_lstate_events(struct ahd_softc *,
@@ -1528,10 +1465,8 @@ extern uint32_t ahd_debug;
 #define AHD_SHOW_INT_COALESCING 0x10000
 #define AHD_DEBUG_SEQUENCER     0x20000
 #endif
-void                    ahd_print_scb(struct scb *scb);
 void                    ahd_print_devinfo(struct ahd_softc *ahd,
                                          struct ahd_devinfo *devinfo);
-void                    ahd_dump_sglist(struct scb *scb);
 void                    ahd_dump_card_state(struct ahd_softc *ahd);
 int                     ahd_print_register(ahd_reg_parse_entry_t *table,
                                           u_int num_entries,
@@ -1540,5 +1475,4 @@ int			ahd_print_register(ahd_reg_parse_entry_t *table,
                                           u_int value,
                                           u_int *cur_column,
                                           u_int wrap_point);
-void                    ahd_dump_scbs(struct ahd_softc *ahd);
 #endif /* _AIC79XX_H_ */
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 653818d2f802..07a86a30f676 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -52,7 +52,7 @@
 /***************************** Lookup Tables **********************************/
-char *ahd_chip_names[] =
+static char *ahd_chip_names[] =
 {
        "NONE",
        "aic7901",
@@ -237,10 +237,33 @@ static int		ahd_handle_target_cmd(struct ahd_softc *ahd,
                                              struct target_cmd *cmd);
 #endif
+static int              ahd_abort_scbs(struct ahd_softc *ahd, int target,
+                                       char channel, int lun, u_int tag,
+                                       role_t role, uint32_t status);
+static void             ahd_alloc_scbs(struct ahd_softc *ahd);
+static void             ahd_busy_tcl(struct ahd_softc *ahd, u_int tcl,
+                                     u_int scbid);
+static void             ahd_calc_residual(struct ahd_softc *ahd,
+                                          struct scb *scb);
+static void             ahd_clear_critical_section(struct ahd_softc *ahd);
+static void             ahd_clear_intstat(struct ahd_softc *ahd);
+static void             ahd_enable_coalescing(struct ahd_softc *ahd,
+                                              int enable);
+static u_int            ahd_find_busy_tcl(struct ahd_softc *ahd, u_int tcl);
+static void             ahd_freeze_devq(struct ahd_softc *ahd,
+                                        struct scb *scb);
+static void             ahd_handle_scb_status(struct ahd_softc *ahd,
+                                              struct scb *scb);
+static struct ahd_phase_table_entry* ahd_lookup_phase_entry(int phase);
+static void             ahd_shutdown(void *arg);
+static void             ahd_update_coalescing_values(struct ahd_softc *ahd,
+                                                     u_int timer,
+                                                     u_int maxcmds,
+                                                     u_int mincmds);
+static int              ahd_verify_vpd_cksum(struct vpd_config *vpd);
+static int              ahd_wait_seeprom(struct ahd_softc *ahd);
 /******************************** Private Inlines *****************************/
-static __inline void    ahd_assert_atn(struct ahd_softc *ahd);
-static __inline int     ahd_currently_packetized(struct ahd_softc *ahd);
-static __inline int     ahd_set_active_fifo(struct ahd_softc *ahd);
 static __inline void
 ahd_assert_atn(struct ahd_softc *ahd)
@@ -294,11 +317,44 @@ ahd_set_active_fifo(struct ahd_softc *ahd)
        }
 }
+static __inline void
+ahd_unbusy_tcl(struct ahd_softc *ahd, u_int tcl)
+{
+        ahd_busy_tcl(ahd, tcl, SCB_LIST_NULL);
+}
+/*
+ * Determine whether the sequencer reported a residual
+ * for this SCB/transaction.
+ */
+static __inline void
+ahd_update_residual(struct ahd_softc *ahd, struct scb *scb)
+{
+        uint32_t sgptr;
+        sgptr = ahd_le32toh(scb->hscb->sgptr);
+        if ((sgptr & SG_STATUS_VALID) != 0)
+                ahd_calc_residual(ahd, scb);
+}
+static __inline void
+ahd_complete_scb(struct ahd_softc *ahd, struct scb *scb)
+{
+        uint32_t sgptr;
+        sgptr = ahd_le32toh(scb->hscb->sgptr);
+        if ((sgptr & SG_STATUS_VALID) != 0)
+                ahd_handle_scb_status(ahd, scb);
+        else
+                ahd_done(ahd, scb);
+}
 /************************* Sequencer Execution Control ************************/
 /*
 * Restart the sequencer program from address zero
 */
-void
+static void
 ahd_restart(struct ahd_softc *ahd)
 {
@@ -342,7 +398,7 @@ ahd_restart(struct ahd_softc *ahd)
        ahd_unpause(ahd);
 }
-void
+static void
 ahd_clear_fifo(struct ahd_softc *ahd, u_int fifo)
 {
        ahd_mode_state   saved_modes;
@@ -366,7 +422,7 @@ ahd_clear_fifo(struct ahd_softc *ahd, u_int fifo)
 * Flush and completed commands that are sitting in the command
 * complete queues down on the chip but have yet to be dma'ed back up.
 */
-void
+static void
 ahd_flush_qoutfifo(struct ahd_softc *ahd)
 {
        struct          scb *scb;
@@ -905,6 +961,51 @@ ahd_handle_hwerrint(struct ahd_softc *ahd)
        ahd_free(ahd);
 }
+#ifdef AHD_DEBUG
+static void
+ahd_dump_sglist(struct scb *scb)
+{
+        int i;
+        if (scb->sg_count > 0) {
+                if ((scb->ahd_softc->flags & AHD_64BIT_ADDRESSING) != 0) {
+                        struct ahd_dma64_seg *sg_list;
+                        sg_list = (struct ahd_dma64_seg*)scb->sg_list;
+                        for (i = 0; i < scb->sg_count; i++) {
+                                uint64_t addr;
+                                uint32_t len;
+                                addr = ahd_le64toh(sg_list[i].addr);
+                                len = ahd_le32toh(sg_list[i].len);
+                                printf("sg[%d] - Addr 0x%x%x : Length %d%s\n",
+                                       i,
+                                       (uint32_t)((addr >> 32) & 0xFFFFFFFF),
+                                       (uint32_t)(addr & 0xFFFFFFFF),
+                                       sg_list[i].len & AHD_SG_LEN_MASK,
+                                       (sg_list[i].len & AHD_DMA_LAST_SEG)
+                                     ? " Last" : "");
+                        }
+                } else {
+                        struct ahd_dma_seg *sg_list;
+                        sg_list = (struct ahd_dma_seg*)scb->sg_list;
+                        for (i = 0; i < scb->sg_count; i++) {
+                                uint32_t len;
+                                len = ahd_le32toh(sg_list[i].len);
+                                printf("sg[%d] - Addr 0x%x%x : Length %d%s\n",
+                                       i,
+                                       (len & AHD_SG_HIGH_ADDR_MASK) >> 24,
+                                       ahd_le32toh(sg_list[i].addr),
+                                       len & AHD_SG_LEN_MASK,
+                                       len & AHD_DMA_LAST_SEG ? " Last" : "");
+                        }
+                }
+        }
+}
+#endif  /*  AHD_DEBUG  */
 void
 ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
 {
@@ -1053,10 +1154,12 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
                         * If a target takes us into the command phase
                         * assume that it has been externally reset and
                         * has thus lost our previous packetized negotiation
-                         * agreement.
+                         * agreement.  Since we have not sent an identify
-                         * Revert to async/narrow transfers until we
+                         * message and may not have fully qualified the
-                         * can renegotiate with the device and notify
+                         * connection, we change our command to TUR, assert
-                         * the OSM about the reset.
+                         * ATN and ABORT the task when we go to message in
+                         * phase.  The OSM will see the REQUEUE_REQUEST
+                         * status and retry the command.
                         */
                        scbid = ahd_get_scbptr(ahd);
                        scb = ahd_lookup_scb(ahd, scbid);
@@ -1083,7 +1186,28 @@ ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
                        ahd_set_syncrate(ahd, &devinfo, /*period*/0,
                                         /*offset*/0, /*ppr_options*/0,
                                         AHD_TRANS_ACTIVE, /*paused*/TRUE);
-                        scb->flags |= SCB_EXTERNAL_RESET;
+                        /* Hand-craft TUR command */
+                        ahd_outb(ahd, SCB_CDB_STORE, 0);
+                        ahd_outb(ahd, SCB_CDB_STORE+1, 0);
+                        ahd_outb(ahd, SCB_CDB_STORE+2, 0);
+                        ahd_outb(ahd, SCB_CDB_STORE+3, 0);
+                        ahd_outb(ahd, SCB_CDB_STORE+4, 0);
+                        ahd_outb(ahd, SCB_CDB_STORE+5, 0);
+                        ahd_outb(ahd, SCB_CDB_LEN, 6);
+                        scb->hscb->control &= ~(TAG_ENB|SCB_TAG_TYPE);
+                        scb->hscb->control |= MK_MESSAGE;
+                        ahd_outb(ahd, SCB_CONTROL, scb->hscb->control);
+                        ahd_outb(ahd, MSG_OUT, HOST_MSG);
+                        ahd_outb(ahd, SAVED_SCSIID, scb->hscb->scsiid);
+                        /*
+                         * The lun is 0, regardless of the SCB's lun
+                         * as we have not sent an identify message.
+                         */
+                        ahd_outb(ahd, SAVED_LUN, 0);
+                        ahd_outb(ahd, SEQ_FLAGS, 0);
+                        ahd_assert_atn(ahd);
+                        scb->flags &= ~SCB_PACKETIZED;
+                        scb->flags |= SCB_ABORT|SCB_EXTERNAL_RESET;
                        ahd_freeze_devq(ahd, scb);
                        ahd_set_transaction_status(scb, CAM_REQUEUE_REQ);
                        ahd_freeze_scb(scb);
@@ -1519,8 +1643,10 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
        /*
         * Ignore external resets after a bus reset.
         */
-        if (((status & SCSIRSTI) != 0) && (ahd->flags & AHD_BUS_RESET_ACTIVE))
+        if (((status & SCSIRSTI) != 0) && (ahd->flags & AHD_BUS_RESET_ACTIVE)) {
+                ahd_outb(ahd, CLRSINT1, CLRSCSIRSTI);
                return;
+        }
        /*
         * Clear bus reset flag
@@ -2200,6 +2326,22 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                        if (sent_msg == MSG_ABORT_TAG)
                                tag = SCB_GET_TAG(scb);
+                        if ((scb->flags & SCB_EXTERNAL_RESET) != 0) {
+                                /*
+                                 * This abort is in response to an
+                                 * unexpected switch to command phase
+                                 * for a packetized connection.  Since
+                                 * the identify message was never sent,
+                                 * "saved lun" is 0.  We really want to
+                                 * abort only the SCB that encountered
+                                 * this error, which could have a different
+                                 * lun.  The SCB will be retried so the OS
+                                 * will see the UA after renegotiating to
+                                 * packetized.
+                                 */
+                                tag = SCB_GET_TAG(scb);
+                                saved_lun = scb->hscb->lun;
+                        }
                        found = ahd_abort_scbs(ahd, target, 'A', saved_lun,
                                               tag, ROLE_INITIATOR,
                                               CAM_REQ_ABORTED);
@@ -2523,7 +2665,7 @@ ahd_force_renegotiation(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
 }
 #define AHD_MAX_STEPS 2000
-void
+static void
 ahd_clear_critical_section(struct ahd_softc *ahd)
 {
        ahd_mode_state  saved_modes;
@@ -2646,7 +2788,7 @@ ahd_clear_critical_section(struct ahd_softc *ahd)
 /*
 * Clear any pending interrupt status.
 */
-void
+static void
 ahd_clear_intstat(struct ahd_softc *ahd)
 {
        AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
@@ -2677,6 +2819,8 @@ ahd_clear_intstat(struct ahd_softc *ahd)
 #ifdef AHD_DEBUG
 uint32_t ahd_debug = AHD_DEBUG_OPTS;
 #endif
+#if 0
 void
 ahd_print_scb(struct scb *scb)
 {
@@ -2701,49 +2845,7 @@ ahd_print_scb(struct scb *scb)
               SCB_GET_TAG(scb));
        ahd_dump_sglist(scb);
 }
+#endif  /*  0  */
-void
-ahd_dump_sglist(struct scb *scb)
-{
-        int i;
-        if (scb->sg_count > 0) {
-                if ((scb->ahd_softc->flags & AHD_64BIT_ADDRESSING) != 0) {
-                        struct ahd_dma64_seg *sg_list;
-                        sg_list = (struct ahd_dma64_seg*)scb->sg_list;
-                        for (i = 0; i < scb->sg_count; i++) {
-                                uint64_t addr;
-                                uint32_t len;
-                                addr = ahd_le64toh(sg_list[i].addr);
-                                len = ahd_le32toh(sg_list[i].len);
-                                printf("sg[%d] - Addr 0x%x%x : Length %d%s\n",
-                                       i,
-                                       (uint32_t)((addr >> 32) & 0xFFFFFFFF),
-                                       (uint32_t)(addr & 0xFFFFFFFF),
-                                       sg_list[i].len & AHD_SG_LEN_MASK,
-                                       (sg_list[i].len & AHD_DMA_LAST_SEG)
-                                     ? " Last" : "");
-                        }
-                } else {
-                        struct ahd_dma_seg *sg_list;
-                        sg_list = (struct ahd_dma_seg*)scb->sg_list;
-                        for (i = 0; i < scb->sg_count; i++) {
-                                uint32_t len;
-                                len = ahd_le32toh(sg_list[i].len);
-                                printf("sg[%d] - Addr 0x%x%x : Length %d%s\n",
-                                       i,
-                                       (len & AHD_SG_HIGH_ADDR_MASK) >> 24,
-                                       ahd_le32toh(sg_list[i].addr),
-                                       len & AHD_SG_LEN_MASK,
-                                       len & AHD_DMA_LAST_SEG ? " Last" : "");
-                        }
-                }
-        }
-}
 /************************* Transfer Negotiation *******************************/
 /*
@@ -2850,14 +2952,14 @@ ahd_devlimited_syncrate(struct ahd_softc *ahd,
                transinfo = &tinfo->goal;
        *ppr_options &= (transinfo->ppr_options|MSG_EXT_PPR_PCOMP_EN);
        if (transinfo->width == MSG_EXT_WDTR_BUS_8_BIT) {
-                maxsync = MAX(maxsync, AHD_SYNCRATE_ULTRA2);
+                maxsync = max(maxsync, (u_int)AHD_SYNCRATE_ULTRA2);
                *ppr_options &= ~MSG_EXT_PPR_DT_REQ;
        }
        if (transinfo->period == 0) {
                *period = 0;
                *ppr_options = 0;
        } else {
-                *period = MAX(*period, transinfo->period);
+                *period = max(*period, (u_int)transinfo->period);
                ahd_find_syncrate(ahd, period, ppr_options, maxsync);
        }
 }
@@ -2906,7 +3008,7 @@ ahd_find_syncrate(struct ahd_softc *ahd, u_int *period,
 * Truncate the given synchronous offset to a value the
 * current adapter type and syncrate are capable of.
 */
-void
+static void
 ahd_validate_offset(struct ahd_softc *ahd,
                    struct ahd_initiator_tinfo *tinfo,
                    u_int period, u_int *offset, int wide,
@@ -2924,12 +3026,12 @@ ahd_validate_offset(struct ahd_softc *ahd,
                        maxoffset = MAX_OFFSET_PACED;
        } else
                maxoffset = MAX_OFFSET_NON_PACED;
-        *offset = MIN(*offset, maxoffset);
+        *offset = min(*offset, maxoffset);
        if (tinfo != NULL) {
                if (role == ROLE_TARGET)
-                        *offset = MIN(*offset, tinfo->user.offset);
+                        *offset = min(*offset, (u_int)tinfo->user.offset);
                else
-                        *offset = MIN(*offset, tinfo->goal.offset);
+                        *offset = min(*offset, (u_int)tinfo->goal.offset);
        }
 }
@@ -2937,7 +3039,7 @@ ahd_validate_offset(struct ahd_softc *ahd,
 * Truncate the given transfer width parameter to a value the
 * current adapter type is capable of.
 */
-void
+static void
 ahd_validate_width(struct ahd_softc *ahd, struct ahd_initiator_tinfo *tinfo,
                   u_int *bus_width, role_t role)
 {
@@ -2955,9 +3057,9 @@ ahd_validate_width(struct ahd_softc *ahd, struct ahd_initiator_tinfo *tinfo,
        }
        if (tinfo != NULL) {
                if (role == ROLE_TARGET)
-                        *bus_width = MIN(tinfo->user.width, *bus_width);
+                        *bus_width = min((u_int)tinfo->user.width, *bus_width);
                else
-                        *bus_width = MIN(tinfo->goal.width, *bus_width);
+                        *bus_width = min((u_int)tinfo->goal.width, *bus_width);
        }
 }
@@ -3210,7 +3312,7 @@ ahd_set_width(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
 /*
 * Update the current state of tagged queuing for a given target.
 */
-void
+static void
 ahd_set_tags(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
             struct ahd_devinfo *devinfo, ahd_queue_alg alg)
 {
@@ -3466,7 +3568,7 @@ ahd_print_devinfo(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
               devinfo->target, devinfo->lun);
 }
-struct ahd_phase_table_entry*
+static struct ahd_phase_table_entry*
 ahd_lookup_phase_entry(int phase)
 {
        struct ahd_phase_table_entry *entry;
@@ -5351,7 +5453,7 @@ ahd_free(struct ahd_softc *ahd)
        return;
 }
-void
+static void
 ahd_shutdown(void *arg)
 {
        struct  ahd_softc *ahd;
@@ -5480,7 +5582,7 @@ ahd_reset(struct ahd_softc *ahd, int reinit)
 /*
 * Determine the number of SCBs available on the controller
 */
-int
+static int
 ahd_probe_scbs(struct ahd_softc *ahd) {
        int i;
@@ -5929,7 +6031,7 @@ ahd_free_scb(struct ahd_softc *ahd, struct scb *scb)
        ahd_platform_scb_free(ahd, scb);
 }
-void
+static void
 ahd_alloc_scbs(struct ahd_softc *ahd)
 {
        struct scb_data *scb_data;
@@ -6057,9 +6159,9 @@ ahd_alloc_scbs(struct ahd_softc *ahd)
 #endif
        }
-        newcount = MIN(scb_data->sense_left, scb_data->scbs_left);
+        newcount = min(scb_data->sense_left, scb_data->scbs_left);
-        newcount = MIN(newcount, scb_data->sgs_left);
+        newcount = min(newcount, scb_data->sgs_left);
-        newcount = MIN(newcount, (AHD_SCB_MAX_ALLOC - scb_data->numscbs));
+        newcount = min(newcount, (AHD_SCB_MAX_ALLOC - scb_data->numscbs));
        for (i = 0; i < newcount; i++) {
                struct scb_platform_data *pdata;
                u_int col_tag;
@@ -6982,7 +7084,7 @@ ahd_intr_enable(struct ahd_softc *ahd, int enable)
        ahd_outb(ahd, HCNTRL, hcntrl);
 }
-void
+static void
 ahd_update_coalescing_values(struct ahd_softc *ahd, u_int timer, u_int maxcmds,
                             u_int mincmds)
 {
@@ -7000,7 +7102,7 @@ ahd_update_coalescing_values(struct ahd_softc *ahd, u_int timer, u_int maxcmds,
        ahd_outb(ahd, INT_COALESCING_MINCMDS, -mincmds);
 }
-void
+static void
 ahd_enable_coalescing(struct ahd_softc *ahd, int enable)
 {
@@ -7070,6 +7172,7 @@ ahd_pause_and_flushwork(struct ahd_softc *ahd)
        ahd->flags &= ~AHD_ALL_INTERRUPTS;
 }
+#if 0
 int
 ahd_suspend(struct ahd_softc *ahd)
 {
@@ -7083,7 +7186,9 @@ ahd_suspend(struct ahd_softc *ahd)
        ahd_shutdown(ahd);
        return (0);
 }
+#endif  /*  0  */
+#if 0
 int
 ahd_resume(struct ahd_softc *ahd)
 {
@@ -7093,6 +7198,7 @@ ahd_resume(struct ahd_softc *ahd)
        ahd_restart(ahd);
        return (0);
 }
+#endif  /*  0  */
 /************************** Busy Target Table *********************************/
 /*
@@ -7125,7 +7231,7 @@ ahd_index_busy_tcl(struct ahd_softc *ahd, u_int *saved_scbid, u_int tcl)
 /*
 * Return the untagged transaction id for a given target/channel lun.
 */
-u_int
+static u_int
 ahd_find_busy_tcl(struct ahd_softc *ahd, u_int tcl)
 {
        u_int scbid;
@@ -7138,7 +7244,7 @@ ahd_find_busy_tcl(struct ahd_softc *ahd, u_int tcl)
        return (scbid);
 }
-void
+static void
 ahd_busy_tcl(struct ahd_softc *ahd, u_int tcl, u_int scbid)
 {
        u_int scb_offset;
@@ -7186,7 +7292,7 @@ ahd_match_scb(struct ahd_softc *ahd, struct scb *scb, int target,
        return match;
 }
-void
+static void
 ahd_freeze_devq(struct ahd_softc *ahd, struct scb *scb)
 {
        int     target;
@@ -7690,7 +7796,7 @@ ahd_add_scb_to_free_list(struct ahd_softc *ahd, u_int scbid)
 * been modified from CAM_REQ_INPROG.  This routine assumes that the sequencer
 * is paused before it is called.
 */
-int
+static int
 ahd_abort_scbs(struct ahd_softc *ahd, int target, char channel,
               int lun, u_int tag, role_t role, uint32_t status)
 {
@@ -7920,6 +8026,11 @@ ahd_reset_channel(struct ahd_softc *ahd, char channel, int initiate_reset)
        ahd_clear_fifo(ahd, 1);
        /*
+         * Clear SCSI interrupt status
+         */
+        ahd_outb(ahd, CLRSINT1, CLRSCSIRSTI);
+        /*
         * Reenable selections
         */
        ahd_outb(ahd, SIMODE1, ahd_inb(ahd, SIMODE1) | ENSCSIRST);
@@ -7952,10 +8063,6 @@ ahd_reset_channel(struct ahd_softc *ahd, char channel, int initiate_reset)
                }
        }
 #endif
-        /* Notify the XPT that a bus reset occurred */
-        ahd_send_async(ahd, devinfo.channel, CAM_TARGET_WILDCARD,
-                       CAM_LUN_WILDCARD, AC_BUS_RESET);
        /*
         * Revert to async/narrow transfers until we renegotiate.
         */
@@ -7977,6 +8084,10 @@ ahd_reset_channel(struct ahd_softc *ahd, char channel, int initiate_reset)
                }
        }
+        /* Notify the XPT that a bus reset occurred */
+        ahd_send_async(ahd, devinfo.channel, CAM_TARGET_WILDCARD,
+                       CAM_LUN_WILDCARD, AC_BUS_RESET);
        ahd_restart(ahd);
        return (found);
@@ -8019,18 +8130,8 @@ ahd_stat_timer(void *arg)
 }
 /****************************** Status Processing *****************************/
-void
-ahd_handle_scb_status(struct ahd_softc *ahd, struct scb *scb)
-{
-        if (scb->hscb->shared_data.istatus.scsi_status != 0) {
-                ahd_handle_scsi_status(ahd, scb);
-        } else {
-                ahd_calc_residual(ahd, scb);
-                ahd_done(ahd, scb);
-        }
-}
-void
+static void
 ahd_handle_scsi_status(struct ahd_softc *ahd, struct scb *scb)
 {
        struct  hardware_scb *hscb;
@@ -8238,10 +8339,21 @@ ahd_handle_scsi_status(struct ahd_softc *ahd, struct scb *scb)
        }
 }
+static void
+ahd_handle_scb_status(struct ahd_softc *ahd, struct scb *scb)
+{
+        if (scb->hscb->shared_data.istatus.scsi_status != 0) {
+                ahd_handle_scsi_status(ahd, scb);
+        } else {
+                ahd_calc_residual(ahd, scb);
+                ahd_done(ahd, scb);
+        }
+}
 /*
 * Calculate the residual for a just completed SCB.
 */
-void
+static void
 ahd_calc_residual(struct ahd_softc *ahd, struct scb *scb)
 {
        struct hardware_scb *hscb;
@@ -8668,7 +8780,7 @@ ahd_resolve_seqaddr(struct ahd_softc *ahd, u_int address)
                if (skip_addr > i) {
                        int end_addr;
-                        end_addr = MIN(address, skip_addr);
+                        end_addr = min(address, skip_addr);
                        address_offset += end_addr - i;
                        i = skip_addr;
                } else {
@@ -9092,6 +9204,7 @@ ahd_dump_card_state(struct ahd_softc *ahd)
                ahd_unpause(ahd);
 }
+#if 0
 void
 ahd_dump_scbs(struct ahd_softc *ahd)
 {
@@ -9117,6 +9230,7 @@ ahd_dump_scbs(struct ahd_softc *ahd)
        ahd_set_scbptr(ahd, saved_scb_index);
        ahd_restore_modes(ahd, saved_modes);
 }
+#endif  /*  0  */
 /**************************** Flexport Logic **********************************/
 /*
@@ -9219,7 +9333,7 @@ ahd_write_seeprom(struct ahd_softc *ahd, uint16_t *buf,
 /*
 * Wait ~100us for the serial eeprom to satisfy our request.
 */
-int
+static int
 ahd_wait_seeprom(struct ahd_softc *ahd)
 {
        int cnt;
@@ -9237,7 +9351,7 @@ ahd_wait_seeprom(struct ahd_softc *ahd)
 * Validate the two checksums in the per_channel
 * vital product data struct.
 */
-int
+static int
 ahd_verify_vpd_cksum(struct vpd_config *vpd)
 {
        int i;
@@ -9316,6 +9430,24 @@ ahd_release_seeprom(struct ahd_softc *ahd)
        /* Currently a no-op */
 }
+/*
+ * Wait at most 2 seconds for flexport arbitration to succeed.
+ */
+static int
+ahd_wait_flexport(struct ahd_softc *ahd)
+{
+        int cnt;
+        AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
+        cnt = 1000000 * 2 / 5;
+        while ((ahd_inb(ahd, BRDCTL) & FLXARBACK) == 0 && --cnt)
+                ahd_delay(5);
+        if (cnt == 0)
+                return (ETIMEDOUT);
+        return (0);
+}
 int
 ahd_write_flexport(struct ahd_softc *ahd, u_int addr, u_int value)
 {
@@ -9357,24 +9489,6 @@ ahd_read_flexport(struct ahd_softc *ahd, u_int addr, uint8_t *value)
        return (0);
 }
-/*
- * Wait at most 2 seconds for flexport arbitration to succeed.
- */
-int
-ahd_wait_flexport(struct ahd_softc *ahd)
-{
-        int cnt;
-        AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
-        cnt = 1000000 * 2 / 5;
-        while ((ahd_inb(ahd, BRDCTL) & FLXARBACK) == 0 && --cnt)
-                ahd_delay(5);
-        if (cnt == 0)
-                return (ETIMEDOUT);
-        return (0);
-}
 /************************* Target Mode ****************************************/
 #ifdef AHD_TARGET_MODE
 cam_status
diff --git a/drivers/scsi/aic7xxx/aic79xx_inline.h b/drivers/scsi/aic7xxx/aic79xx_inline.h
index a3266e066c00..2ceb67f4af2a 100644
--- a/drivers/scsi/aic7xxx/aic79xx_inline.h
+++ b/drivers/scsi/aic7xxx/aic79xx_inline.h
@@ -418,10 +418,6 @@ ahd_targetcmd_offset(struct ahd_softc *ahd, u_int index)
 }
 /*********************** Miscelaneous Support Functions ***********************/
-static __inline void    ahd_complete_scb(struct ahd_softc *ahd,
-                                         struct scb *scb);
-static __inline void    ahd_update_residual(struct ahd_softc *ahd,
-                                            struct scb *scb);
 static __inline struct ahd_initiator_tinfo *
                        ahd_fetch_transinfo(struct ahd_softc *ahd,
                                            char channel, u_int our_id,
@@ -467,32 +463,6 @@ static __inline uint32_t
                        ahd_get_sense_bufaddr(struct ahd_softc *ahd,
                                              struct scb *scb);
-static __inline void
-ahd_complete_scb(struct ahd_softc *ahd, struct scb *scb)
-{
-        uint32_t sgptr;
-        sgptr = ahd_le32toh(scb->hscb->sgptr);
-        if ((sgptr & SG_STATUS_VALID) != 0)
-                ahd_handle_scb_status(ahd, scb);
-        else
-                ahd_done(ahd, scb);
-}
-/*
- * Determine whether the sequencer reported a residual
- * for this SCB/transaction.
- */
-static __inline void
-ahd_update_residual(struct ahd_softc *ahd, struct scb *scb)
-{
-        uint32_t sgptr;
-        sgptr = ahd_le32toh(scb->hscb->sgptr);
-        if ((sgptr & SG_STATUS_VALID) != 0)
-                ahd_calc_residual(ahd, scb);
-}
 /*
 * Return pointers to the transfer negotiation information
 * for the specified our_id/remote_id pair.
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index f8e60486167d..9bfcca5ede08 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -293,7 +293,7 @@ static uint32_t aic79xx_seltime;
 * force all outstanding transactions to be serviced prior to a new
 * transaction.
 */
-uint32_t aic79xx_periodic_otag;
+static uint32_t aic79xx_periodic_otag;
 /* Some storage boxes are using an LSI chip which has a bug making it
 * impossible to use aic79xx Rev B chip in 320 speeds.  The following
@@ -773,6 +773,7 @@ struct scsi_host_template aic79xx_driver_template = {
 #endif
        .can_queue              = AHD_MAX_QUEUE,
        .this_id                = -1,
+        .max_sectors            = 8192,
        .cmd_per_lun            = 2,
        .use_clustering         = ENABLE_CLUSTERING,
        .slave_alloc            = ahd_linux_slave_alloc,
@@ -1813,9 +1814,9 @@ ahd_linux_handle_scsi_status(struct ahd_softc *ahd,
                        u_int sense_offset;
                        if (scb->flags & SCB_SENSE) {
-                                sense_size = MIN(sizeof(struct scsi_sense_data)
+                                sense_size = min(sizeof(struct scsi_sense_data)
                                               - ahd_get_sense_residual(scb),
-                                                 sizeof(cmd->sense_buffer));
+                                                 (u_long)sizeof(cmd->sense_buffer));
                                sense_offset = 0;
                        } else {
                                /*
@@ -1824,7 +1825,8 @@ ahd_linux_handle_scsi_status(struct ahd_softc *ahd,
                                 */
                                siu = (struct scsi_status_iu_header *)
                                    scb->sense_data;
-                                sense_size = MIN(scsi_4btoul(siu->sense_length),
+                                sense_size = min_t(size_t,
+                                                scsi_4btoul(siu->sense_length),
                                                sizeof(cmd->sense_buffer));
                                sense_offset = SIU_SENSE_OFFSET(siu);
                        }
@@ -2634,8 +2636,22 @@ static void ahd_linux_set_pcomp_en(struct scsi_target *starget, int pcomp)
                       pcomp ? "Enable" : "Disable");
 #endif
-        if (pcomp)
+        if (pcomp) {
+                uint8_t precomp;
+                if (ahd->unit < ARRAY_SIZE(aic79xx_iocell_info)) {
+                        struct ahd_linux_iocell_opts *iocell_opts;
+                        iocell_opts = &aic79xx_iocell_info[ahd->unit];
+                        precomp = iocell_opts->precomp;
+                } else {
+                        precomp = AIC79XX_DEFAULT_PRECOMP;
+                }
                ppr_options |= MSG_EXT_PPR_PCOMP_EN;
+                AHD_SET_PRECOMP(ahd, precomp);
+        } else {
+                AHD_SET_PRECOMP(ahd, 0);
+        }
        ahd_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
                            starget->channel + 'A', ROLE_INITIATOR);
@@ -2678,7 +2694,25 @@ static void ahd_linux_set_hold_mcs(struct scsi_target *starget, int hold)
        ahd_unlock(ahd, &flags);
 }
+static void ahd_linux_get_signalling(struct Scsi_Host *shost)
+{
+        struct ahd_softc *ahd = *(struct ahd_softc **)shost->hostdata;
+        unsigned long flags;
+        u8 mode;
+        ahd_lock(ahd, &flags);
+        ahd_pause(ahd);
+        mode = ahd_inb(ahd, SBLKCTL);
+        ahd_unpause(ahd);
+        ahd_unlock(ahd, &flags);
+        if (mode & ENAB40)
+                spi_signalling(shost) = SPI_SIGNAL_LVD;
+        else if (mode & ENAB20)
+                spi_signalling(shost) = SPI_SIGNAL_SE;
+        else
+                spi_signalling(shost) = SPI_SIGNAL_UNKNOWN;
+}
 static struct spi_function_template ahd_linux_transport_functions = {
        .set_offset     = ahd_linux_set_offset,
@@ -2703,6 +2737,7 @@ static struct spi_function_template ahd_linux_transport_functions = {
        .show_pcomp_en  = 1,
        .set_hold_mcs   = ahd_linux_set_hold_mcs,
        .show_hold_mcs  = 1,
+        .get_signalling = ahd_linux_get_signalling,
 };
 static int __init
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.h b/drivers/scsi/aic7xxx/aic79xx_osm.h
index fb3d4dd54413..3a67fc578d78 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.h
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.h
@@ -506,9 +506,6 @@ struct info_str {
        int pos;
 };
-void    ahd_format_transinfo(struct info_str *info,
-                             struct ahd_transinfo *tinfo);
 /******************************** Locking *************************************/
 static __inline void
 ahd_lockinit(struct ahd_softc *ahd)
@@ -582,8 +579,6 @@ ahd_unlock(struct ahd_softc *ahd, unsigned long *flags)
 #define PCIXM_STATUS_MAXCRDS    0x1C00  /* Maximum Cumulative Read Size */
 #define PCIXM_STATUS_RCVDSCEM   0x2000  /* Received a Split Comp w/Error msg */
-extern struct pci_driver aic79xx_pci_driver;
 typedef enum
 {
        AHD_POWER_STATE_D0,
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
index 4b5354201807..2001fe890e71 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
@@ -82,7 +82,7 @@ static struct pci_device_id ahd_linux_pci_id_table[] = {
 MODULE_DEVICE_TABLE(pci, ahd_linux_pci_id_table);
-struct pci_driver aic79xx_pci_driver = {
+static struct pci_driver aic79xx_pci_driver = {
        .name           = "aic79xx",
        .probe          = ahd_linux_pci_dev_probe,
        .remove         = ahd_linux_pci_dev_remove,
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.c b/drivers/scsi/aic7xxx/aic79xx_pci.c
index 14850f31aafa..c07735819cd1 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.c
@@ -97,7 +97,7 @@ static ahd_device_setup_t ahd_aic7901A_setup;
 static ahd_device_setup_t ahd_aic7902_setup;
 static ahd_device_setup_t ahd_aic790X_setup;
-struct ahd_pci_identity ahd_pci_ident_table [] =
+static struct ahd_pci_identity ahd_pci_ident_table [] =
 {
        /* aic7901 based controllers */
        {
@@ -201,7 +201,7 @@ struct ahd_pci_identity ahd_pci_ident_table [] =
        }
 };
-const u_int ahd_num_pci_devs = ARRAY_SIZE(ahd_pci_ident_table);
+static const u_int ahd_num_pci_devs = ARRAY_SIZE(ahd_pci_ident_table);
                
 #define DEVCONFIG               0x40
 #define         PCIXINITPAT     0x0000E000ul
@@ -245,6 +245,7 @@ static int	ahd_check_extport(struct ahd_softc *ahd);
 static void     ahd_configure_termination(struct ahd_softc *ahd,
                                          u_int adapter_control);
 static void     ahd_pci_split_intr(struct ahd_softc *ahd, u_int intstat);
+static void     ahd_pci_intr(struct ahd_softc *ahd);
 struct ahd_pci_identity *
 ahd_find_pci_device(ahd_dev_softc_t pci)
@@ -757,7 +758,7 @@ static const char *pci_status_strings[] =
        "%s: Address or Write Phase Parity Error Detected in %s.\n"
 };
-void
+static void
 ahd_pci_intr(struct ahd_softc *ahd)
 {
        uint8_t         pci_status[8];
diff --git a/drivers/scsi/aic7xxx/aic79xx_proc.c b/drivers/scsi/aic7xxx/aic79xx_proc.c
index c5f0ee591509..6b28bebcbca0 100644
--- a/drivers/scsi/aic7xxx/aic79xx_proc.c
+++ b/drivers/scsi/aic7xxx/aic79xx_proc.c
@@ -136,7 +136,7 @@ copy_info(struct info_str *info, char *fmt, ...)
        return (len);
 }
-void
+static void
 ahd_format_transinfo(struct info_str *info, struct ahd_transinfo *tinfo)
 {
        u_int speed;
diff --git a/drivers/scsi/aic7xxx/aic7xxx.h b/drivers/scsi/aic7xxx/aic7xxx.h
index 62ff8c3dc2bb..954c7c24501d 100644
--- a/drivers/scsi/aic7xxx/aic7xxx.h
+++ b/drivers/scsi/aic7xxx/aic7xxx.h
@@ -54,14 +54,6 @@ struct scb_platform_data;
 struct seeprom_descriptor;
 /****************************** Useful Macros *********************************/
-#ifndef MAX
-#define MAX(a,b) (((a) > (b)) ? (a) : (b))
-#endif
-#ifndef MIN
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
-#endif
 #ifndef TRUE
 #define TRUE 1
 #endif
@@ -1135,8 +1127,6 @@ struct ahc_pci_identity {
        char                    *name;
        ahc_device_setup_t      *setup;
 };
-extern struct ahc_pci_identity ahc_pci_ident_table[];
-extern const u_int ahc_num_pci_devs;
 /***************************** VL/EISA Declarations ***************************/
 struct aic7770_identity {
@@ -1289,6 +1279,7 @@ typedef enum {
 } ahc_queue_alg;
 void                    ahc_set_tags(struct ahc_softc *ahc,
+                                     struct scsi_cmnd *cmd,
                                     struct ahc_devinfo *devinfo,
                                     ahc_queue_alg alg);
diff --git a/drivers/scsi/aic7xxx/aic7xxx_core.c b/drivers/scsi/aic7xxx/aic7xxx_core.c
index 93e4e40944b6..50ef785224de 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_core.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_core.c
@@ -1671,7 +1671,7 @@ ahc_devlimited_syncrate(struct ahc_softc *ahc,
                transinfo = &tinfo->goal;
        *ppr_options &= transinfo->ppr_options;
        if (transinfo->width == MSG_EXT_WDTR_BUS_8_BIT) {
-                maxsync = MAX(maxsync, AHC_SYNCRATE_ULTRA2);
+                maxsync = max(maxsync, (u_int)AHC_SYNCRATE_ULTRA2);
                *ppr_options &= ~MSG_EXT_PPR_DT_REQ;
        }
        if (transinfo->period == 0) {
@@ -1679,7 +1679,7 @@ ahc_devlimited_syncrate(struct ahc_softc *ahc,
                *ppr_options = 0;
                return (NULL);
        }
-        *period = MAX(*period, transinfo->period);
+        *period = max(*period, (u_int)transinfo->period);
        return (ahc_find_syncrate(ahc, period, ppr_options, maxsync));
 }
@@ -1804,12 +1804,12 @@ ahc_validate_offset(struct ahc_softc *ahc,
                else
                        maxoffset = MAX_OFFSET_8BIT;
        }
-        *offset = MIN(*offset, maxoffset);
+        *offset = min(*offset, maxoffset);
        if (tinfo != NULL) {
                if (role == ROLE_TARGET)
-                        *offset = MIN(*offset, tinfo->user.offset);
+                        *offset = min(*offset, (u_int)tinfo->user.offset);
                else
-                        *offset = MIN(*offset, tinfo->goal.offset);
+                        *offset = min(*offset, (u_int)tinfo->goal.offset);
        }
 }
@@ -1835,9 +1835,9 @@ ahc_validate_width(struct ahc_softc *ahc, struct ahc_initiator_tinfo *tinfo,
        }
        if (tinfo != NULL) {
                if (role == ROLE_TARGET)
-                        *bus_width = MIN(tinfo->user.width, *bus_width);
+                        *bus_width = min((u_int)tinfo->user.width, *bus_width);
                else
-                        *bus_width = MIN(tinfo->goal.width, *bus_width);
+                        *bus_width = min((u_int)tinfo->goal.width, *bus_width);
        }
 }
@@ -1986,7 +1986,7 @@ ahc_set_syncrate(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
                tinfo->curr.ppr_options = ppr_options;
                ahc_send_async(ahc, devinfo->channel, devinfo->target,
-                               CAM_LUN_WILDCARD, AC_TRANSFER_NEG, NULL);
+                               CAM_LUN_WILDCARD, AC_TRANSFER_NEG);
                if (bootverbose) {
                        if (offset != 0) {
                                printf("%s: target %d synchronous at %sMHz%s, "
@@ -2056,7 +2056,7 @@ ahc_set_width(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
                tinfo->curr.width = width;
                ahc_send_async(ahc, devinfo->channel, devinfo->target,
-                               CAM_LUN_WILDCARD, AC_TRANSFER_NEG, NULL);
+                               CAM_LUN_WILDCARD, AC_TRANSFER_NEG);
                if (bootverbose) {
                        printf("%s: target %d using %dbit transfers\n",
                               ahc_name(ahc), devinfo->target,
@@ -2074,12 +2074,14 @@ ahc_set_width(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
 * Update the current state of tagged queuing for a given target.
 */
 void
-ahc_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
+ahc_set_tags(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
-             ahc_queue_alg alg)
+             struct ahc_devinfo *devinfo, ahc_queue_alg alg)
 {
-        ahc_platform_set_tags(ahc, devinfo, alg);
+        struct scsi_device *sdev = cmd->device;
+        ahc_platform_set_tags(ahc, sdev, devinfo, alg);
        ahc_send_async(ahc, devinfo->channel, devinfo->target,
-                       devinfo->lun, AC_TRANSFER_NEG, &alg);
+                       devinfo->lun, AC_TRANSFER_NEG);
 }
 /*
@@ -3489,7 +3491,7 @@ ahc_handle_msg_reject(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
                        printf("(%s:%c:%d:%d): refuses tagged commands.  "
                               "Performing non-tagged I/O\n", ahc_name(ahc),
                               devinfo->channel, devinfo->target, devinfo->lun);
-                        ahc_set_tags(ahc, devinfo, AHC_QUEUE_NONE);
+                        ahc_set_tags(ahc, scb->io_ctx, devinfo, AHC_QUEUE_NONE);
                        mask = ~0x23;
                } else {
                        printf("(%s:%c:%d:%d): refuses %s tagged commands.  "
@@ -3497,7 +3499,7 @@ ahc_handle_msg_reject(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
                               ahc_name(ahc), devinfo->channel, devinfo->target,
                               devinfo->lun, tag_type == MSG_ORDERED_TASK
                               ? "ordered" : "head of queue");
-                        ahc_set_tags(ahc, devinfo, AHC_QUEUE_BASIC);
+                        ahc_set_tags(ahc, scb->io_ctx, devinfo, AHC_QUEUE_BASIC);
                        mask = ~0x03;
                }
@@ -3763,7 +3765,7 @@ ahc_handle_devreset(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
        
        if (status != CAM_SEL_TIMEOUT)
                ahc_send_async(ahc, devinfo->channel, devinfo->target,
-                               CAM_LUN_WILDCARD, AC_SENT_BDR, NULL);
+                               CAM_LUN_WILDCARD, AC_SENT_BDR);
        if (message != NULL
         && (verbose_level <= bootverbose))
@@ -4406,7 +4408,7 @@ ahc_alloc_scbs(struct ahc_softc *ahc)
        physaddr = sg_map->sg_physaddr;
        newcount = (PAGE_SIZE / (AHC_NSEG * sizeof(struct ahc_dma_seg)));
-        newcount = MIN(newcount, (AHC_SCB_MAX_ALLOC - scb_data->numscbs));
+        newcount = min(newcount, (AHC_SCB_MAX_ALLOC - scb_data->numscbs));
        for (i = 0; i < newcount; i++) {
                struct scb_platform_data *pdata;
 #ifndef __linux__
@@ -6018,7 +6020,7 @@ ahc_reset_channel(struct ahc_softc *ahc, char channel, int initiate_reset)
 #endif
        /* Notify the XPT that a bus reset occurred */
        ahc_send_async(ahc, devinfo.channel, CAM_TARGET_WILDCARD,
-                       CAM_LUN_WILDCARD, AC_BUS_RESET, NULL);
+                       CAM_LUN_WILDCARD, AC_BUS_RESET);
        /*
         * Revert to async/narrow transfers until we renegotiate.
@@ -6442,7 +6444,7 @@ ahc_download_instr(struct ahc_softc *ahc, u_int instrptr, uint8_t *dconsts)
                        if (skip_addr > i) {
                                int end_addr;
-                                end_addr = MIN(address, skip_addr);
+                                end_addr = min(address, skip_addr);
                                address_offset += end_addr - i;
                                i = skip_addr;
                        } else {
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index 43ab753d2739..660f26e23a38 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -328,7 +328,7 @@ static uint32_t aic7xxx_seltime;
 * force all outstanding transactions to be serviced prior to a new
 * transaction.
 */
-uint32_t aic7xxx_periodic_otag;
+static uint32_t aic7xxx_periodic_otag;
 /*
 * Module information and settable options.
@@ -512,7 +512,6 @@ ahc_linux_target_alloc(struct scsi_target *starget)
        struct seeprom_config *sc = ahc->seep_config;
        unsigned long flags;
        struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);
-        struct ahc_linux_target *targ = scsi_transport_target_data(starget);
        unsigned short scsirate;
        struct ahc_devinfo devinfo;
        struct ahc_initiator_tinfo *tinfo;
@@ -533,7 +532,6 @@ ahc_linux_target_alloc(struct scsi_target *starget)
        BUG_ON(*ahc_targp != NULL);
        *ahc_targp = starget;
-        memset(targ, 0, sizeof(*targ));
        if (sc) {
                int maxsync = AHC_SYNCRATE_DT;
@@ -594,14 +592,11 @@ ahc_linux_slave_alloc(struct scsi_device *sdev)
        struct  ahc_softc *ahc =
                *((struct ahc_softc **)sdev->host->hostdata);
        struct scsi_target *starget = sdev->sdev_target;
-        struct ahc_linux_target *targ = scsi_transport_target_data(starget);
        struct ahc_linux_device *dev;
        if (bootverbose)
                printf("%s: Slave Alloc %d\n", ahc_name(ahc), sdev->id);
-        BUG_ON(targ->sdev[sdev->lun] != NULL);
        dev = scsi_transport_device_data(sdev);
        memset(dev, 0, sizeof(*dev));
@@ -618,8 +613,6 @@ ahc_linux_slave_alloc(struct scsi_device *sdev)
         */
        dev->maxtags = 0;
        
-        targ->sdev[sdev->lun] = sdev;
        spi_period(starget) = 0;
        return 0;
@@ -644,22 +637,6 @@ ahc_linux_slave_configure(struct scsi_device *sdev)
        return 0;
 }
-static void
-ahc_linux_slave_destroy(struct scsi_device *sdev)
-{
-        struct  ahc_softc *ahc;
-        struct  ahc_linux_device *dev = scsi_transport_device_data(sdev);
-        struct  ahc_linux_target *targ = scsi_transport_target_data(sdev->sdev_target);
-        ahc = *((struct ahc_softc **)sdev->host->hostdata);
-        if (bootverbose)
-                printf("%s: Slave Destroy %d\n", ahc_name(ahc), sdev->id);
-        BUG_ON(dev->active);
-        targ->sdev[sdev->lun] = NULL;
-}
 #if defined(__i386__)
 /*
 * Return the disk geometry for the given SCSI device.
@@ -777,11 +754,11 @@ struct scsi_host_template aic7xxx_driver_template = {
 #endif
        .can_queue              = AHC_MAX_QUEUE,
        .this_id                = -1,
+        .max_sectors            = 8192,
        .cmd_per_lun            = 2,
        .use_clustering         = ENABLE_CLUSTERING,
        .slave_alloc            = ahc_linux_slave_alloc,
        .slave_configure        = ahc_linux_slave_configure,
-        .slave_destroy          = ahc_linux_slave_destroy,
        .target_alloc           = ahc_linux_target_alloc,
        .target_destroy         = ahc_linux_target_destroy,
 };
@@ -1203,21 +1180,13 @@ void
 ahc_platform_free(struct ahc_softc *ahc)
 {
        struct scsi_target *starget;
-        int i, j;
+        int i;
        if (ahc->platform_data != NULL) {
                /* destroy all of the device and target objects */
                for (i = 0; i < AHC_NUM_TARGETS; i++) {
                        starget = ahc->platform_data->starget[i];
                        if (starget != NULL) {
-                                for (j = 0; j < AHC_NUM_LUNS; j++) {
-                                        struct ahc_linux_target *targ =
-                                                scsi_transport_target_data(starget);
-                                        if (targ->sdev[j] == NULL)
-                                                continue;
-                                        targ->sdev[j] = NULL;
-                                }
                                ahc->platform_data->starget[i] = NULL;
                        }
                }
@@ -1251,24 +1220,13 @@ ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb)
 }
 void
-ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
+ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
-                      ahc_queue_alg alg)
+                      struct ahc_devinfo *devinfo, ahc_queue_alg alg)
 {
-        struct scsi_target *starget;
-        struct ahc_linux_target *targ;
        struct ahc_linux_device *dev;
-        struct scsi_device *sdev;
-        u_int target_offset;
        int was_queuing;
        int now_queuing;
-        target_offset = devinfo->target;
-        if (devinfo->channel != 'A')
-                target_offset += 8;
-        starget = ahc->platform_data->starget[target_offset];
-        targ = scsi_transport_target_data(starget);
-        BUG_ON(targ == NULL);
-        sdev = targ->sdev[devinfo->lun];
        if (sdev == NULL)
                return;
        dev = scsi_transport_device_data(sdev);
@@ -1401,11 +1359,15 @@ ahc_linux_device_queue_depth(struct scsi_device *sdev)
        tags = ahc_linux_user_tagdepth(ahc, &devinfo);
        if (tags != 0 && sdev->tagged_supported != 0) {
-                ahc_set_tags(ahc, &devinfo, AHC_QUEUE_TAGGED);
+                ahc_platform_set_tags(ahc, sdev, &devinfo, AHC_QUEUE_TAGGED);
+                ahc_send_async(ahc, devinfo.channel, devinfo.target,
+                               devinfo.lun, AC_TRANSFER_NEG);
                ahc_print_devinfo(ahc, &devinfo);
                printf("Tagged Queuing enabled.  Depth %d\n", tags);
        } else {
-                ahc_set_tags(ahc, &devinfo, AHC_QUEUE_NONE);
+                ahc_platform_set_tags(ahc, sdev, &devinfo, AHC_QUEUE_NONE);
+                ahc_send_async(ahc, devinfo.channel, devinfo.target,
+                               devinfo.lun, AC_TRANSFER_NEG);
        }
 }
@@ -1629,7 +1591,7 @@ ahc_platform_flushwork(struct ahc_softc *ahc)
 void
 ahc_send_async(struct ahc_softc *ahc, char channel,
-               u_int target, u_int lun, ac_code code, void *arg)
+               u_int target, u_int lun, ac_code code)
 {
        switch (code) {
        case AC_TRANSFER_NEG:
@@ -1875,9 +1837,9 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                if (scb->flags & SCB_SENSE) {
                        u_int sense_size;
-                        sense_size = MIN(sizeof(struct scsi_sense_data)
+                        sense_size = min(sizeof(struct scsi_sense_data)
                                       - ahc_get_sense_residual(scb),
-                                         sizeof(cmd->sense_buffer));
+                                         (u_long)sizeof(cmd->sense_buffer));
                        memcpy(cmd->sense_buffer,
                               ahc_get_sense_buf(ahc, scb), sense_size);
                        if (sense_size < sizeof(cmd->sense_buffer))
@@ -1946,7 +1908,7 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                        }
                        ahc_set_transaction_status(scb, CAM_REQUEUE_REQ);
                        ahc_set_scsi_status(scb, SCSI_STATUS_OK);
-                        ahc_platform_set_tags(ahc, &devinfo,
+                        ahc_platform_set_tags(ahc, sdev, &devinfo,
                                     (dev->flags & AHC_DEV_Q_BASIC)
                                   ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
                        break;
@@ -1957,7 +1919,7 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                 */
                dev->openings = 1;
                ahc_set_scsi_status(scb, SCSI_STATUS_BUSY);
-                ahc_platform_set_tags(ahc, &devinfo,
+                ahc_platform_set_tags(ahc, sdev, &devinfo,
                             (dev->flags & AHC_DEV_Q_BASIC)
                           ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
                break;
@@ -2599,8 +2561,6 @@ ahc_linux_init(void)
        if (!ahc_linux_transport_template)
                return -ENODEV;
-        scsi_transport_reserve_target(ahc_linux_transport_template,
-                                      sizeof(struct ahc_linux_target));
        scsi_transport_reserve_device(ahc_linux_transport_template,
                                      sizeof(struct ahc_linux_device));
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.h b/drivers/scsi/aic7xxx/aic7xxx_osm.h
index a87a4ce090df..85ae5d836fa4 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.h
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.h
@@ -256,7 +256,6 @@ typedef enum {
        AHC_DEV_PERIODIC_OTAG    = 0x40, /* Send OTAG to prevent starvation */
 } ahc_linux_dev_flags;
-struct ahc_linux_target;
 struct ahc_linux_device {
        /*
         * The number of transactions currently
@@ -329,12 +328,6 @@ struct ahc_linux_device {
 #define AHC_OTAG_THRESH 500
 };
-struct ahc_linux_target {
-        struct scsi_device       *sdev[AHC_NUM_LUNS];
-        struct ahc_transinfo      last_tinfo;
-        struct ahc_softc         *ahc;
-};
 /********************* Definitions Required by the Core ***********************/
 /*
 * Number of SG segments we require.  So long as the S/G segments for
@@ -533,8 +526,6 @@ ahc_unlock(struct ahc_softc *ahc, unsigned long *flags)
 #define PCIR_SUBVEND_0  0x2c
 #define PCIR_SUBDEV_0   0x2e
-extern struct pci_driver aic7xxx_pci_driver;
 typedef enum
 {
        AHC_POWER_STATE_D0,
@@ -824,7 +815,7 @@ ahc_freeze_scb(struct scb *scb)
        }
 }
-void    ahc_platform_set_tags(struct ahc_softc *ahc,
+void    ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
                              struct ahc_devinfo *devinfo, ahc_queue_alg);
 int     ahc_platform_abort_scbs(struct ahc_softc *ahc, int target,
                                char channel, int lun, u_int tag,
@@ -834,7 +825,7 @@ irqreturn_t
 void    ahc_platform_flushwork(struct ahc_softc *ahc);
 void    ahc_done(struct ahc_softc*, struct scb*);
 void    ahc_send_async(struct ahc_softc *, char channel,
-                       u_int target, u_int lun, ac_code, void *);
+                       u_int target, u_int lun, ac_code);
 void    ahc_print_path(struct ahc_softc *, struct scb *);
 void    ahc_platform_dump_card_state(struct ahc_softc *ahc);
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c b/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
index d20ca514e9f3..ea5687df732d 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
@@ -130,7 +130,7 @@ static struct pci_device_id ahc_linux_pci_id_table[] = {
 MODULE_DEVICE_TABLE(pci, ahc_linux_pci_id_table);
-struct pci_driver aic7xxx_pci_driver = {
+static struct pci_driver aic7xxx_pci_driver = {
        .name           = "aic7xxx",
        .probe          = ahc_linux_pci_dev_probe,
        .remove         = ahc_linux_pci_dev_remove,
diff --git a/drivers/scsi/aic7xxx/aic7xxx_pci.c b/drivers/scsi/aic7xxx/aic7xxx_pci.c
index 63cab2d74552..09c8172c9e5e 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_pci.c
@@ -168,7 +168,7 @@ static ahc_device_setup_t ahc_aha394XX_setup;
 static ahc_device_setup_t ahc_aha494XX_setup;
 static ahc_device_setup_t ahc_aha398XX_setup;
-struct ahc_pci_identity ahc_pci_ident_table [] =
+static struct ahc_pci_identity ahc_pci_ident_table [] =
 {
        /* aic7850 based controllers */
        {
@@ -559,7 +559,7 @@ struct ahc_pci_identity ahc_pci_ident_table [] =
        }
 };
-const u_int ahc_num_pci_devs = ARRAY_SIZE(ahc_pci_ident_table);
+static const u_int ahc_num_pci_devs = ARRAY_SIZE(ahc_pci_ident_table);
                
 #define AHC_394X_SLOT_CHANNEL_A 4
 #define AHC_394X_SLOT_CHANNEL_B 5
diff --git a/drivers/scsi/aic7xxx/aic7xxx_proc.c b/drivers/scsi/aic7xxx/aic7xxx_proc.c
index 5914b4aa4a8f..99e5443e7535 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_proc.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_proc.c
@@ -182,7 +182,6 @@ ahc_dump_target_state(struct ahc_softc *ahc, struct info_str *info,
                      u_int our_id, char channel, u_int target_id,
                      u_int target_offset)
 {
-        struct  ahc_linux_target *targ;
        struct  scsi_target *starget;
        struct  ahc_initiator_tinfo *tinfo;
        struct  ahc_tmode_tstate *tstate;
@@ -198,7 +197,6 @@ ahc_dump_target_state(struct ahc_softc *ahc, struct info_str *info,
        starget = ahc->platform_data->starget[target_offset];
        if (!starget)
                return;
-        targ = scsi_transport_target_data(starget);
        copy_info(info, "\tGoal: ");
        ahc_format_transinfo(info, &tinfo->goal);
@@ -208,7 +206,7 @@ ahc_dump_target_state(struct ahc_softc *ahc, struct info_str *info,
        for (lun = 0; lun < AHC_NUM_LUNS; lun++) {
                struct scsi_device *sdev;
-                sdev = targ->sdev[lun];
+                sdev = scsi_device_lookup_by_target(starget, lun);
                if (sdev == NULL)
                        continue;
@@ -383,11 +381,11 @@ ahc_linux_proc_info(struct Scsi_Host *shost, char *buffer, char **start,
        }
        copy_info(&info, "\n");
-        max_targ = 15;
+        max_targ = 16;
        if ((ahc->features & (AHC_WIDE|AHC_TWIN)) == 0)
-                max_targ = 7;
+                max_targ = 8;
-        for (i = 0; i <= max_targ; i++) {
+        for (i = 0; i < max_targ; i++) {
                u_int our_id;
                u_int target_id;
                char channel;
diff --git a/drivers/scsi/aic7xxx_old.c b/drivers/scsi/aic7xxx_old.c
index bcd7fffab907..46eed10b25d9 100644
--- a/drivers/scsi/aic7xxx_old.c
+++ b/drivers/scsi/aic7xxx_old.c
@@ -2646,7 +2646,7 @@ static void aic7xxx_done_cmds_complete(struct aic7xxx_host *p)
        while (p->completeq.head != NULL) {
                cmd = p->completeq.head;
-                p->completeq.head = (struct scsi_Cmnd *) cmd->host_scribble;
+                p->completeq.head = (struct scsi_cmnd *) cmd->host_scribble;
                cmd->host_scribble = NULL;
                cmd->scsi_done(cmd);
        }
diff --git a/drivers/scsi/aic94xx/aic94xx_hwi.h b/drivers/scsi/aic94xx/aic94xx_hwi.h
index 14319d1d6804..7b6aca02cf70 100644
--- a/drivers/scsi/aic94xx/aic94xx_hwi.h
+++ b/drivers/scsi/aic94xx/aic94xx_hwi.h
@@ -46,6 +46,7 @@
 #define PCI_DEVICE_ID_ADAPTEC2_RAZOR10 0x410
 #define PCI_DEVICE_ID_ADAPTEC2_RAZOR12 0x412
 #define PCI_DEVICE_ID_ADAPTEC2_RAZOR1E 0x41E
+#define PCI_DEVICE_ID_ADAPTEC2_RAZOR1F 0x41F
 #define PCI_DEVICE_ID_ADAPTEC2_RAZOR30 0x430
 #define PCI_DEVICE_ID_ADAPTEC2_RAZOR32 0x432
 #define PCI_DEVICE_ID_ADAPTEC2_RAZOR3E 0x43E
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index 99743ca29ca1..a4cc432bbdab 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -814,6 +814,8 @@ static const struct pci_device_id aic94xx_pci_table[] __devinitdata = {
         0, 0, 1},
        {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_RAZOR1E),
         0, 0, 1},
+        {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_RAZOR1F),
+         0, 0, 1},
        {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_RAZOR30),
         0, 0, 2},
        {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_RAZOR32),
diff --git a/drivers/scsi/aic94xx/aic94xx_sds.c b/drivers/scsi/aic94xx/aic94xx_sds.c
index 83574b5b4e69..de7c04d4254d 100644
--- a/drivers/scsi/aic94xx/aic94xx_sds.c
+++ b/drivers/scsi/aic94xx/aic94xx_sds.c
@@ -630,10 +630,6 @@ static int asd_flash_getid(struct asd_ha_struct *asd_ha)
        reg = asd_read_reg_dword(asd_ha, EXSICNFGR);
-        if (!(reg & FLASHEX)) {
-                ASD_DPRINTK("flash doesn't exist\n");
-                return -ENOENT;
-        }
        if (pci_read_config_dword(asd_ha->pcidev, PCI_CONF_FLSH_BAR,
                                  &asd_ha->hw_prof.flash.bar)) {
                asd_printk("couldn't read PCI_CONF_FLSH_BAR of %s\n",
diff --git a/drivers/scsi/fdomain.c b/drivers/scsi/fdomain.c
index 65e6e7b7ba07..5d4ea6f77953 100644
--- a/drivers/scsi/fdomain.c
+++ b/drivers/scsi/fdomain.c
@@ -387,6 +387,7 @@ static void __iomem *    bios_mem;
 static int               bios_major;
 static int               bios_minor;
 static int               PCI_bus;
+static struct pci_dev   *PCI_dev;
 static int               Quantum;       /* Quantum board variant */
 static int               interrupt_level;
 static volatile int      in_command;
@@ -812,9 +813,10 @@ static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_
           PCI_DEVICE_ID_FD_36C70 );
 #endif 
-   if ((pdev = pci_find_device(PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70, pdev)) == NULL)
+   if ((pdev = pci_get_device(PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70, pdev)) == NULL)
                return 0;
-   if (pci_enable_device(pdev)) return 0;
+   if (pci_enable_device(pdev))
+        goto fail;
       
 #if DEBUG_DETECT
   printk( "scsi: <fdomain> TMC-3260 detect:"
@@ -831,7 +833,7 @@ static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_
   pci_irq = pdev->irq;
   if (!request_region( pci_base, 0x10, "fdomain" ))
-        return 0;
+        goto fail;
   /* Now we have the I/O base address and interrupt from the PCI
      configuration registers. */
@@ -848,17 +850,22 @@ static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_
   if (!fdomain_is_valid_port(pci_base)) {
      printk(KERN_ERR "scsi: <fdomain> PCI card detected, but driver not loaded (invalid port)\n" );
      release_region(pci_base, 0x10);
-      return 0;
+      goto fail;
   }
                                /* Fill in a few global variables.  Ugh. */
   bios_major = bios_minor = -1;
   PCI_bus    = 1;
+   PCI_dev    = pdev;
   Quantum    = 0;
   bios_base  = 0;
   
   return 1;
+fail:
+   pci_dev_put(pdev);
+   return 0;
 }
 #endif
 struct Scsi_Host *__fdomain_16x0_detect(struct scsi_host_template *tpnt )
@@ -909,8 +916,7 @@ struct Scsi_Host *__fdomain_16x0_detect(struct scsi_host_template *tpnt )
      if (setup_called) {
         printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
      }
-      release_region(port_base, 0x10);
+      goto fail;
-      return NULL;
   }
   if (this_id) {
@@ -942,8 +948,7 @@ struct Scsi_Host *__fdomain_16x0_detect(struct scsi_host_template *tpnt )
   /* Log IRQ with kernel */   
   if (!interrupt_level) {
      printk(KERN_ERR "scsi: <fdomain> Card Detected, but driver not loaded (no IRQ)\n" );
-      release_region(port_base, 0x10);
+      goto fail;
-      return NULL;
   } else {
      /* Register the IRQ with the kernel */
@@ -964,11 +969,14 @@ struct Scsi_Host *__fdomain_16x0_detect(struct scsi_host_template *tpnt )
            printk(KERN_ERR "                Send mail to faith@acm.org\n" );
         }
         printk(KERN_ERR "scsi: <fdomain> Detected, but driver not loaded (IRQ)\n" );
-         release_region(port_base, 0x10);
+         goto fail;
-         return NULL;
      }
   }
   return shpnt;
+fail:
+   pci_dev_put(pdev);
+   release_region(port_base, 0x10);
+   return NULL;
 }
 static int fdomain_16x0_detect(struct scsi_host_template *tpnt)
@@ -1714,6 +1722,8 @@ static int fdomain_16x0_release(struct Scsi_Host *shpnt)
                free_irq(shpnt->irq, shpnt);
        if (shpnt->io_port && shpnt->n_io_port)
                release_region(shpnt->io_port, shpnt->n_io_port);
+        if (PCI_bus)
+                pci_dev_put(PCI_dev);
        return 0;
 }
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 669ea4fff166..fbc1d5c3b0a7 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1213,7 +1213,7 @@ void ibmvscsi_handle_crq(struct viosrp_crq *crq,
                               "ibmvscsi: Re-enabling adapter!\n");
                        purge_requests(hostdata, DID_REQUEUE);
                        if ((ibmvscsi_reenable_crq_queue(&hostdata->queue,
-                                                        hostdata) == 0) ||
+                                                        hostdata)) ||
                            (ibmvscsi_send_crq(hostdata,
                                               0xC001000000000000LL, 0))) {
                                        atomic_set(&hostdata->request_limit,
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index c542d0e95e68..2865ebd557ef 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -481,8 +481,8 @@ int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
                        break;
                case ISCSI_OP_ASYNC_EVENT:
                        conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
-                        /* we need sth like iscsi_async_event_rsp() */
+                        if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
-                        rc = ISCSI_ERR_BAD_OPCODE;
+                                rc = ISCSI_ERR_CONN_FAILED;
                        break;
                default:
                        rc = ISCSI_ERR_BAD_OPCODE;
@@ -578,6 +578,27 @@ void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
 }
 EXPORT_SYMBOL_GPL(iscsi_conn_failure);
+static int iscsi_xmit_imm_task(struct iscsi_conn *conn)
+{
+        struct iscsi_hdr *hdr = conn->mtask->hdr;
+        int rc, was_logout = 0;
+        if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) {
+                conn->session->state = ISCSI_STATE_IN_RECOVERY;
+                iscsi_block_session(session_to_cls(conn->session));
+                was_logout = 1;
+        }
+        rc = conn->session->tt->xmit_mgmt_task(conn, conn->mtask);
+        if (rc)
+                return rc;
+        if (was_logout) {
+                set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
+                return -ENODATA;
+        }
+        return 0;
+}
 /**
 * iscsi_data_xmit - xmit any command into the scheduled connection
 * @conn: iscsi connection
@@ -623,7 +644,7 @@ static int iscsi_data_xmit(struct iscsi_conn *conn)
                conn->ctask = NULL;
        }
        if (conn->mtask) {
-                rc = tt->xmit_mgmt_task(conn, conn->mtask);
+                rc = iscsi_xmit_imm_task(conn);
                if (rc)
                        goto again;
                /* done with this in-progress mtask */
@@ -638,7 +659,7 @@ static int iscsi_data_xmit(struct iscsi_conn *conn)
                        list_add_tail(&conn->mtask->running,
                                      &conn->mgmt_run_list);
                        spin_unlock_bh(&conn->session->lock);
-                        rc = tt->xmit_mgmt_task(conn, conn->mtask);
+                        rc = iscsi_xmit_imm_task(conn);
                        if (rc)
                                goto again;
                }
@@ -661,8 +682,6 @@ static int iscsi_data_xmit(struct iscsi_conn *conn)
                spin_unlock_bh(&conn->session->lock);
                rc = tt->xmit_cmd_task(conn, conn->ctask);
-                if (rc)
-                        goto again;
                spin_lock_bh(&conn->session->lock);
                __iscsi_put_ctask(conn->ctask);
@@ -778,6 +797,10 @@ int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
        }
        conn = session->leadconn;
+        if (!conn) {
+                reason = FAILURE_SESSION_FREED;
+                goto fault;
+        }
        if (!__kfifo_get(session->cmdpool.queue, (void*)&ctask,
                         sizeof(void*))) {
@@ -1377,7 +1400,6 @@ iscsi_session_setup(struct iscsi_transport *iscsit,
        }
        spin_lock_init(&session->lock);
-        INIT_LIST_HEAD(&session->connections);
        /* initialize immediate command pool */
        if (iscsi_pool_init(&session->mgmtpool, session->mgmtpool_max,
@@ -1580,16 +1602,11 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
        kfree(conn->persistent_address);
        __kfifo_put(session->mgmtpool.queue, (void*)&conn->login_mtask,
                    sizeof(void*));
-        list_del(&conn->item);
+        if (session->leadconn == conn) {
-        if (list_empty(&session->connections))
                session->leadconn = NULL;
-        if (session->leadconn && session->leadconn == conn)
-                session->leadconn = container_of(session->connections.next,
-                        struct iscsi_conn, item);
-        if (session->leadconn == NULL)
                /* no connections exits.. reset sequencing */
                session->cmdsn = session->max_cmdsn = session->exp_cmdsn = 1;
+        }
        spin_unlock_bh(&session->lock);
        kfifo_free(conn->immqueue);
@@ -1777,32 +1794,12 @@ int iscsi_conn_bind(struct iscsi_cls_session *cls_session,
                    struct iscsi_cls_conn *cls_conn, int is_leading)
 {
        struct iscsi_session *session = class_to_transport_session(cls_session);
-        struct iscsi_conn *tmp = ERR_PTR(-EEXIST), *conn = cls_conn->dd_data;
+        struct iscsi_conn *conn = cls_conn->dd_data;
-        /* lookup for existing connection */
        spin_lock_bh(&session->lock);
-        list_for_each_entry(tmp, &session->connections, item) {
-                if (tmp == conn) {
-                        if (conn->c_stage != ISCSI_CONN_STOPPED ||
-                            conn->stop_stage == STOP_CONN_TERM) {
-                                printk(KERN_ERR "iscsi: can't bind "
-                                       "non-stopped connection (%d:%d)\n",
-                                       conn->c_stage, conn->stop_stage);
-                                spin_unlock_bh(&session->lock);
-                                return -EIO;
-                        }
-                        break;
-                }
-        }
-        if (tmp != conn) {
-                /* bind new iSCSI connection to session */
-                conn->session = session;
-                list_add(&conn->item, &session->connections);
-        }
-        spin_unlock_bh(&session->lock);
        if (is_leading)
                session->leadconn = conn;
+        spin_unlock_bh(&session->lock);
        /*
         * Unblock xmitworker(), Login Phase will pass through.
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 9496e87c135e..2a4e02e7a392 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -594,7 +594,8 @@ lpfc_soft_wwpn_show(struct class_device *cdev, char *buf)
 {
        struct Scsi_Host *host = class_to_shost(cdev);
        struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata;
-        return snprintf(buf, PAGE_SIZE, "0x%llx\n", phba->cfg_soft_wwpn);
+        return snprintf(buf, PAGE_SIZE, "0x%llx\n",
+                        (unsigned long long)phba->cfg_soft_wwpn);
 }
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 1b53afb1cb57..3add7c237859 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -188,7 +188,8 @@ lpfc_alloc_ct_rsp(struct lpfc_hba * phba, int cmdcode, struct ulp_bde64 * bpl,
                if (!mp->virt) {
                        kfree(mp);
-                        lpfc_free_ct_rsp(phba, mlist);
+                        if (mlist)
+                                lpfc_free_ct_rsp(phba, mlist);
                        return NULL;
                }
diff --git a/drivers/scsi/pcmcia/nsp_cs.c b/drivers/scsi/pcmcia/nsp_cs.c
index b1d346049525..f2d79c3f0b8e 100644
--- a/drivers/scsi/pcmcia/nsp_cs.c
+++ b/drivers/scsi/pcmcia/nsp_cs.c
@@ -183,7 +183,7 @@ static void nsp_cs_dmessage(const char *func, int line, int mask, char *fmt, ...
 * Clenaup parameters and call done() functions.
 * You must be set SCpnt->result before call this function.
 */
-static void nsp_scsi_done(Scsi_Cmnd *SCpnt)
+static void nsp_scsi_done(struct scsi_cmnd *SCpnt)
 {
        nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
@@ -192,7 +192,8 @@ static void nsp_scsi_done(Scsi_Cmnd *SCpnt)
        SCpnt->scsi_done(SCpnt);
 }
-static int nsp_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
+static int nsp_queuecommand(struct scsi_cmnd *SCpnt,
+                            void (*done)(struct scsi_cmnd *))
 {
 #ifdef NSP_DEBUG
        /*unsigned int host_id = SCpnt->device->host->this_id;*/
@@ -365,7 +366,7 @@ static int nsphw_init(nsp_hw_data *data)
 /*
 * Start selection phase
 */
-static int nsphw_start_selection(Scsi_Cmnd *SCpnt)
+static int nsphw_start_selection(struct scsi_cmnd *SCpnt)
 {
        unsigned int  host_id    = SCpnt->device->host->this_id;
        unsigned int  base       = SCpnt->device->host->io_port;
@@ -446,7 +447,7 @@ static struct nsp_sync_table nsp_sync_table_20M[] = {
 /*
 * setup synchronous data transfer mode
 */
-static int nsp_analyze_sdtr(Scsi_Cmnd *SCpnt)
+static int nsp_analyze_sdtr(struct scsi_cmnd *SCpnt)
 {
        unsigned char          target = scmd_id(SCpnt);
 //      unsigned char          lun    = SCpnt->device->lun;
@@ -504,7 +505,7 @@ static int nsp_analyze_sdtr(Scsi_Cmnd *SCpnt)
 /*
 * start ninja hardware timer
 */
-static void nsp_start_timer(Scsi_Cmnd *SCpnt, int time)
+static void nsp_start_timer(struct scsi_cmnd *SCpnt, int time)
 {
        unsigned int base = SCpnt->device->host->io_port;
        nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
@@ -517,7 +518,8 @@ static void nsp_start_timer(Scsi_Cmnd *SCpnt, int time)
 /*
 * wait for bus phase change
 */
-static int nsp_negate_signal(Scsi_Cmnd *SCpnt, unsigned char mask, char *str)
+static int nsp_negate_signal(struct scsi_cmnd *SCpnt, unsigned char mask,
+                             char *str)
 {
        unsigned int  base = SCpnt->device->host->io_port;
        unsigned char reg;
@@ -544,9 +546,9 @@ static int nsp_negate_signal(Scsi_Cmnd *SCpnt, unsigned char mask, char *str)
 /*
 * expect Ninja Irq
 */
-static int nsp_expect_signal(Scsi_Cmnd     *SCpnt,
+static int nsp_expect_signal(struct scsi_cmnd *SCpnt,
-                             unsigned char  current_phase,
+                             unsigned char current_phase,
-                             unsigned char  mask)
+                             unsigned char mask)
 {
        unsigned int  base       = SCpnt->device->host->io_port;
        int           time_out;
@@ -579,7 +581,7 @@ static int nsp_expect_signal(Scsi_Cmnd	   *SCpnt,
 /*
 * transfer SCSI message
 */
-static int nsp_xfer(Scsi_Cmnd *SCpnt, int phase)
+static int nsp_xfer(struct scsi_cmnd *SCpnt, int phase)
 {
        unsigned int  base = SCpnt->device->host->io_port;
        nsp_hw_data  *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
@@ -619,7 +621,7 @@ static int nsp_xfer(Scsi_Cmnd *SCpnt, int phase)
 /*
 * get extra SCSI data from fifo
 */
-static int nsp_dataphase_bypass(Scsi_Cmnd *SCpnt)
+static int nsp_dataphase_bypass(struct scsi_cmnd *SCpnt)
 {
        nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
        unsigned int count;
@@ -651,7 +653,7 @@ static int nsp_dataphase_bypass(Scsi_Cmnd *SCpnt)
 /*
 * accept reselection
 */
-static int nsp_reselected(Scsi_Cmnd *SCpnt)
+static int nsp_reselected(struct scsi_cmnd *SCpnt)
 {
        unsigned int  base    = SCpnt->device->host->io_port;
        unsigned int  host_id = SCpnt->device->host->this_id;
@@ -690,7 +692,7 @@ static int nsp_reselected(Scsi_Cmnd *SCpnt)
 /*
 * count how many data transferd
 */
-static int nsp_fifo_count(Scsi_Cmnd *SCpnt)
+static int nsp_fifo_count(struct scsi_cmnd *SCpnt)
 {
        unsigned int base = SCpnt->device->host->io_port;
        unsigned int count;
@@ -717,7 +719,7 @@ static int nsp_fifo_count(Scsi_Cmnd *SCpnt)
 /*
 * read data in DATA IN phase
 */
-static void nsp_pio_read(Scsi_Cmnd *SCpnt)
+static void nsp_pio_read(struct scsi_cmnd *SCpnt)
 {
        unsigned int  base      = SCpnt->device->host->io_port;
        unsigned long mmio_base = SCpnt->device->host->base;
@@ -812,7 +814,7 @@ static void nsp_pio_read(Scsi_Cmnd *SCpnt)
 /*
 * write data in DATA OUT phase
 */
-static void nsp_pio_write(Scsi_Cmnd *SCpnt)
+static void nsp_pio_write(struct scsi_cmnd *SCpnt)
 {
        unsigned int  base      = SCpnt->device->host->io_port;
        unsigned long mmio_base = SCpnt->device->host->base;
@@ -905,7 +907,7 @@ static void nsp_pio_write(Scsi_Cmnd *SCpnt)
 /*
 * setup synchronous/asynchronous data transfer mode
 */
-static int nsp_nexus(Scsi_Cmnd *SCpnt)
+static int nsp_nexus(struct scsi_cmnd *SCpnt)
 {
        unsigned int   base   = SCpnt->device->host->io_port;
        unsigned char  target = scmd_id(SCpnt);
@@ -952,7 +954,7 @@ static irqreturn_t nspintr(int irq, void *dev_id)
 {
        unsigned int   base;
        unsigned char  irq_status, irq_phase, phase;
-        Scsi_Cmnd     *tmpSC;
+        struct scsi_cmnd *tmpSC;
        unsigned char  target, lun;
        unsigned int  *sync_neg;
        int            i, tmp;
@@ -1530,7 +1532,7 @@ nsp_proc_info(
 /*---------------------------------------------------------------*/
 /*
-static int nsp_eh_abort(Scsi_Cmnd *SCpnt)
+static int nsp_eh_abort(struct scsi_cmnd *SCpnt)
 {
        nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
@@ -1558,7 +1560,7 @@ static int nsp_bus_reset(nsp_hw_data *data)
        return SUCCESS;
 }
-static int nsp_eh_bus_reset(Scsi_Cmnd *SCpnt)
+static int nsp_eh_bus_reset(struct scsi_cmnd *SCpnt)
 {
        nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
@@ -1567,7 +1569,7 @@ static int nsp_eh_bus_reset(Scsi_Cmnd *SCpnt)
        return nsp_bus_reset(data);
 }
-static int nsp_eh_host_reset(Scsi_Cmnd *SCpnt)
+static int nsp_eh_host_reset(struct scsi_cmnd *SCpnt)
 {
        nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
diff --git a/drivers/scsi/pcmcia/nsp_cs.h b/drivers/scsi/pcmcia/nsp_cs.h
index a88714f4c05b..625ca97da52d 100644
--- a/drivers/scsi/pcmcia/nsp_cs.h
+++ b/drivers/scsi/pcmcia/nsp_cs.h
@@ -266,7 +266,7 @@ typedef struct _nsp_hw_data {
        int           TimerCount;
        int           SelectionTimeOut;
-        Scsi_Cmnd    *CurrentSC;
+        struct scsi_cmnd *CurrentSC;
        //int           CurrnetTarget;
        int           FifoCount;
@@ -319,30 +319,34 @@ static        int        nsp_proc_info  (
                                         int     hostno,
 #endif
                                         int     inout);
-static        int        nsp_queuecommand(Scsi_Cmnd *SCpnt, void (* done)(Scsi_Cmnd *SCpnt));
+static int nsp_queuecommand(struct scsi_cmnd *SCpnt,
+                            void (* done)(struct scsi_cmnd *SCpnt));
 /* Error handler */
-/*static int nsp_eh_abort       (Scsi_Cmnd *SCpnt);*/
+/*static int nsp_eh_abort       (struct scsi_cmnd *SCpnt);*/
-/*static int nsp_eh_device_reset(Scsi_Cmnd *SCpnt);*/
+/*static int nsp_eh_device_reset(struct scsi_cmnd *SCpnt);*/
-static int nsp_eh_bus_reset    (Scsi_Cmnd *SCpnt);
+static int nsp_eh_bus_reset    (struct scsi_cmnd *SCpnt);
-static int nsp_eh_host_reset   (Scsi_Cmnd *SCpnt);
+static int nsp_eh_host_reset   (struct scsi_cmnd *SCpnt);
 static int nsp_bus_reset       (nsp_hw_data *data);
 /* */
 static int  nsphw_init           (nsp_hw_data *data);
-static int  nsphw_start_selection(Scsi_Cmnd *SCpnt);
+static int  nsphw_start_selection(struct scsi_cmnd *SCpnt);
-static void nsp_start_timer      (Scsi_Cmnd *SCpnt, int time);
+static void nsp_start_timer      (struct scsi_cmnd *SCpnt, int time);
-static int  nsp_fifo_count       (Scsi_Cmnd *SCpnt);
+static int  nsp_fifo_count       (struct scsi_cmnd *SCpnt);
-static void nsp_pio_read         (Scsi_Cmnd *SCpnt);
+static void nsp_pio_read         (struct scsi_cmnd *SCpnt);
-static void nsp_pio_write        (Scsi_Cmnd *SCpnt);
+static void nsp_pio_write        (struct scsi_cmnd *SCpnt);
-static int  nsp_nexus            (Scsi_Cmnd *SCpnt);
+static int  nsp_nexus            (struct scsi_cmnd *SCpnt);
-static void nsp_scsi_done        (Scsi_Cmnd *SCpnt);
+static void nsp_scsi_done        (struct scsi_cmnd *SCpnt);
-static int  nsp_analyze_sdtr     (Scsi_Cmnd *SCpnt);
+static int  nsp_analyze_sdtr     (struct scsi_cmnd *SCpnt);
-static int  nsp_negate_signal    (Scsi_Cmnd *SCpnt, unsigned char mask, char *str);
+static int  nsp_negate_signal    (struct scsi_cmnd *SCpnt,
-static int  nsp_expect_signal    (Scsi_Cmnd *SCpnt, unsigned char current_phase, unsigned char  mask);
+                                  unsigned char mask, char *str);
-static int  nsp_xfer             (Scsi_Cmnd *SCpnt, int phase);
+static int  nsp_expect_signal    (struct scsi_cmnd *SCpnt,
-static int  nsp_dataphase_bypass (Scsi_Cmnd *SCpnt);
+                                  unsigned char current_phase,
-static int  nsp_reselected       (Scsi_Cmnd *SCpnt);
+                                  unsigned char  mask);
+static int  nsp_xfer             (struct scsi_cmnd *SCpnt, int phase);
+static int  nsp_dataphase_bypass (struct scsi_cmnd *SCpnt);
+static int  nsp_reselected       (struct scsi_cmnd *SCpnt);
 static struct Scsi_Host *nsp_detect(struct scsi_host_template *sht);
 /* Interrupt handler */
@@ -355,8 +359,8 @@ static void __exit nsp_cs_exit(void);
 /* Debug */
 #ifdef NSP_DEBUG
-static void show_command (Scsi_Cmnd *SCpnt);
+static void show_command (struct scsi_cmnd *SCpnt);
-static void show_phase   (Scsi_Cmnd *SCpnt);
+static void show_phase   (struct scsi_cmnd *SCpnt);
 static void show_busphase(unsigned char stat);
 static void show_message (nsp_hw_data *data);
 #else
diff --git a/drivers/scsi/pcmcia/nsp_debug.c b/drivers/scsi/pcmcia/nsp_debug.c
index 62e5c60067fd..2f75fe6e35a7 100644
--- a/drivers/scsi/pcmcia/nsp_debug.c
+++ b/drivers/scsi/pcmcia/nsp_debug.c
@@ -138,12 +138,12 @@ static void print_commandk (unsigned char *command)
        printk("\n");
 }
-static void show_command(Scsi_Cmnd *SCpnt)
+static void show_command(struct scsi_cmnd *SCpnt)
 {
        print_commandk(SCpnt->cmnd);
 }
-static void show_phase(Scsi_Cmnd *SCpnt)
+static void show_phase(struct scsi_cmnd *SCpnt)
 {
        int i = SCpnt->SCp.phase;
diff --git a/drivers/scsi/pcmcia/nsp_message.c b/drivers/scsi/pcmcia/nsp_message.c
index d7057737ff34..ef593b70d0f0 100644
--- a/drivers/scsi/pcmcia/nsp_message.c
+++ b/drivers/scsi/pcmcia/nsp_message.c
@@ -8,7 +8,7 @@
 /* $Id: nsp_message.c,v 1.6 2003/07/26 14:21:09 elca Exp $ */
-static void nsp_message_in(Scsi_Cmnd *SCpnt)
+static void nsp_message_in(struct scsi_cmnd *SCpnt)
 {
        unsigned int  base = SCpnt->device->host->io_port;
        nsp_hw_data  *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
@@ -50,7 +50,7 @@ static void nsp_message_in(Scsi_Cmnd *SCpnt)
 }
-static void nsp_message_out(Scsi_Cmnd *SCpnt)
+static void nsp_message_out(struct scsi_cmnd *SCpnt)
 {
        nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
        int ret = 1;
diff --git a/drivers/scsi/psi240i.c b/drivers/scsi/psi240i.c
index a720c9265e66..ac0419e2714a 100644
--- a/drivers/scsi/psi240i.c
+++ b/drivers/scsi/psi240i.c
@@ -87,11 +87,11 @@ typedef struct
        {
        USHORT           ports[13];
        OUR_DEVICE       device[8];
-        Scsi_Cmnd       *pSCmnd;
+        struct scsi_cmnd *pSCmnd;
        IDE_STRUCT       ide;
        ULONG            startSector;
        USHORT           sectorCount;
-        Scsi_Cmnd       *SCpnt;
+        struct scsi_cmnd *SCpnt;
        VOID            *buffer;
        USHORT           expectingIRQ;
        }       ADAPTER240I, *PADAPTER240I;
@@ -253,12 +253,12 @@ static ULONG DecodeError (struct Scsi_Host *pshost, UCHAR status)
 ****************************************************************/
 static void Irq_Handler (int irq, void *dev_id)
        {
-        struct Scsi_Host   *shost;                      // Pointer to host data block
+        struct Scsi_Host *shost;        // Pointer to host data block
-        PADAPTER240I            padapter;               // Pointer to adapter control structure
+        PADAPTER240I padapter;          // Pointer to adapter control structure
-        USHORT                     *pports;                     // I/O port array
+        USHORT *pports;                 // I/O port array
-        Scsi_Cmnd                  *SCpnt;
+        struct scsi_cmnd *SCpnt;
-        UCHAR                           status;
+        UCHAR status;
-        int                                     z;
+        int z;
        DEB(printk ("\npsi240i received interrupt\n"));
@@ -389,12 +389,17 @@ static irqreturn_t do_Irq_Handler (int irq, void *dev_id)
 *      Returns:                Status code.
 *
 ****************************************************************/
-static int Psi240i_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
+static int Psi240i_QueueCommand(struct scsi_cmnd *SCpnt,
+                                void (*done)(struct scsi_cmnd *))
        {
-        UCHAR              *cdb = (UCHAR *)SCpnt->cmnd;                                 // Pointer to SCSI CDB
+        UCHAR *cdb = (UCHAR *)SCpnt->cmnd;
-        PADAPTER240I    padapter = HOSTDATA (SCpnt->device->host);                      // Pointer to adapter control structure
+        // Pointer to SCSI CDB
-        POUR_DEVICE             pdev     = &padapter->device [SCpnt->device->id];// Pointer to device information
+        PADAPTER240I padapter = HOSTDATA (SCpnt->device->host);
-        UCHAR                   rc;                                                                                     // command return code
+        // Pointer to adapter control structure
+        POUR_DEVICE pdev = &padapter->device [SCpnt->device->id];
+        // Pointer to device information
+        UCHAR rc;
+        // command return code
        SCpnt->scsi_done = done;
        padapter->ide.ide.ides.spigot = pdev->spigot;
diff --git a/drivers/scsi/psi240i.h b/drivers/scsi/psi240i.h
index 6a598766df51..21ebb9214004 100644
--- a/drivers/scsi/psi240i.h
+++ b/drivers/scsi/psi240i.h
@@ -309,7 +309,7 @@ typedef struct _IDENTIFY_DATA2 {
 #endif  // PSI_EIDE_SCSIOP
 // function prototypes
-int Psi240i_Command                     (Scsi_Cmnd *SCpnt);
+int Psi240i_Command(struct scsi_cmnd *SCpnt);
-int Psi240i_Abort                       (Scsi_Cmnd *SCpnt);
+int Psi240i_Abort(struct scsi_cmnd *SCpnt);
-int Psi240i_Reset                       (Scsi_Cmnd *SCpnt, unsigned int flags);
+int Psi240i_Reset(struct scsi_cmnd *SCpnt, unsigned int flags);
 #endif
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 2521d548dd59..16af5b79e587 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -931,11 +931,10 @@ qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
        case BUS_RESET:
                if (qla1280_verbose)
-                        printk(KERN_INFO "qla1280(%ld:%d): Issuing BUS "
+                        printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
-                               "DEVICE RESET\n", ha->host_no, bus);
+                               "reset.\n", ha->host_no, bus);
-                if (qla1280_bus_reset(ha, bus == 0))
+                if (qla1280_bus_reset(ha, bus) == 0)
                        result = SUCCESS;
                break;
        case ADAPTER_RESET:
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index ee75a71f3c66..285c8e8ff1a0 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -379,21 +379,37 @@ static struct bin_attribute sysfs_sfp_attr = {
        .read = qla2x00_sysfs_read_sfp,
 };
+static struct sysfs_entry {
+        char *name;
+        struct bin_attribute *attr;
+        int is4GBp_only;
+} bin_file_entries[] = {
+        { "fw_dump", &sysfs_fw_dump_attr, },
+        { "nvram", &sysfs_nvram_attr, },
+        { "optrom", &sysfs_optrom_attr, },
+        { "optrom_ctl", &sysfs_optrom_ctl_attr, },
+        { "vpd", &sysfs_vpd_attr, 1 },
+        { "sfp", &sysfs_sfp_attr, 1 },
+        { 0 },
+};
 void
 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
 {
        struct Scsi_Host *host = ha->host;
+        struct sysfs_entry *iter;
+        int ret;
-        sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
+        for (iter = bin_file_entries; iter->name; iter++) {
-        sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
+                if (iter->is4GBp_only && (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)))
-        sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_optrom_attr);
+                        continue;
-        sysfs_create_bin_file(&host->shost_gendev.kobj,
-            &sysfs_optrom_ctl_attr);
+                ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
-        if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
+                    iter->attr);
-                sysfs_create_bin_file(&host->shost_gendev.kobj,
+                if (ret)
-                    &sysfs_vpd_attr);
+                        qla_printk(KERN_INFO, ha,
-                sysfs_create_bin_file(&host->shost_gendev.kobj,
+                            "Unable to create sysfs %s binary attribute "
-                    &sysfs_sfp_attr);
+                            "(%d).\n", iter->name, ret);
        }
 }
@@ -401,17 +417,14 @@ void
 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
 {
        struct Scsi_Host *host = ha->host;
+        struct sysfs_entry *iter;
+        for (iter = bin_file_entries; iter->name; iter++) {
+                if (iter->is4GBp_only && (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)))
+                        continue;
-        sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
-        sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
-        sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_optrom_attr);
-        sysfs_remove_bin_file(&host->shost_gendev.kobj,
-            &sysfs_optrom_ctl_attr);
-        if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
-                sysfs_remove_bin_file(&host->shost_gendev.kobj,
-                    &sysfs_vpd_attr);
                sysfs_remove_bin_file(&host->shost_gendev.kobj,
-                    &sysfs_sfp_attr);
+                    iter->attr);
        }
        if (ha->beacon_blink_led == 1)
diff --git a/drivers/scsi/qla2xxx/qla_dbg.h b/drivers/scsi/qla2xxx/qla_dbg.h
index 90dad7e88985..5b12278968e0 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.h
+++ b/drivers/scsi/qla2xxx/qla_dbg.h
@@ -38,7 +38,7 @@
 * Macros use for debugging the driver.
 */
-#define DEBUG(x)        do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG(x)        do { if (ql2xextended_error_logging) { x; } } while (0)
 #if defined(QL_DEBUG_LEVEL_1)
 #define DEBUG1(x)       do {x;} while (0)
@@ -46,12 +46,12 @@
 #define DEBUG1(x)       do {} while (0)
 #endif
-#define DEBUG2(x)       do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG2(x)       do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_3(x)     do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG2_3(x)     do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_3_11(x)  do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG2_3_11(x)  do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_9_10(x)  do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG2_9_10(x)  do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_11(x)    do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG2_11(x)    do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_13(x)    do { if (qla2_extended_error_logging) { x; } } while (0)
+#define DEBUG2_13(x)    do { if (ql2xextended_error_logging) { x; } } while (0)
 #if defined(QL_DEBUG_LEVEL_3)
 #define DEBUG3(x)       do {x;} while (0)
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index bab33f6d0bdb..c4fc40f8e8ca 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -1545,6 +1545,9 @@ typedef struct fc_port {
        spinlock_t rport_lock;
        struct fc_rport *rport, *drport;
        u32 supported_classes;
+        unsigned long last_queue_full;
+        unsigned long last_ramp_up;
 } fc_port_t;
 /*
@@ -2255,6 +2258,7 @@ typedef struct scsi_qla_host {
        uint16_t        mgmt_svr_loop_id;
        uint32_t        login_retry_count;
+        int             max_q_depth;
        /* Fibre Channel Device List. */
        struct list_head        fcports;
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 7da69832d74c..32ebeec45ff0 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -48,6 +48,7 @@ extern void qla2x00_update_fcport(scsi_qla_host_t *, fc_port_t *);
 extern void qla2x00_reg_remote_port(scsi_qla_host_t *, fc_port_t *);
 extern void qla2x00_alloc_fw_dump(scsi_qla_host_t *);
+extern void qla2x00_try_to_stop_firmware(scsi_qla_host_t *);
 /*
 * Global Data in qla_os.c source file.
@@ -60,7 +61,8 @@ extern int ql2xplogiabsentdevice;
 extern int ql2xloginretrycount;
 extern int ql2xfdmienable;
 extern int ql2xallocfwdump;
-extern int qla2_extended_error_logging;
+extern int ql2xextended_error_logging;
+extern int ql2xqfullrampup;
 extern void qla2x00_sp_compl(scsi_qla_host_t *, srb_t *);
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 833b93085fd3..08cb5e3fb553 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1644,7 +1644,7 @@ qla2x00_nvram_config(scsi_qla_host_t *ha)
         * Set host adapter parameters.
         */
        if (nv->host_p[0] & BIT_7)
-                qla2_extended_error_logging = 1;
+                ql2xextended_error_logging = 1;
        ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
        /* Always load RISC code on non ISP2[12]00 chips. */
        if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
@@ -3948,3 +3948,24 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr)
 fail_fw_integrity:
        return QLA_FUNCTION_FAILED;
 }
+void
+qla2x00_try_to_stop_firmware(scsi_qla_host_t *ha)
+{
+        int ret, retries;
+        if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
+                return;
+        ret = qla2x00_stop_firmware(ha);
+        for (retries = 5; ret != QLA_SUCCESS && retries ; retries--) {
+                qla2x00_reset_chip(ha);
+                if (qla2x00_chip_diag(ha) != QLA_SUCCESS)
+                        continue;
+                if (qla2x00_setup_chip(ha) != QLA_SUCCESS)
+                        continue;
+                qla_printk(KERN_INFO, ha,
+                    "Attempting retry of stop-firmware command...\n");
+                ret = qla2x00_stop_firmware(ha);
+        }
+}
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 626c7178a434..d3b6df4d55c8 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -6,6 +6,8 @@
 */
 #include "qla_def.h"
+#include <scsi/scsi_tcq.h>
 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
 static void qla2x00_async_event(scsi_qla_host_t *, uint16_t *);
 static void qla2x00_process_completed_request(struct scsi_qla_host *, uint32_t);
@@ -593,6 +595,67 @@ qla2x00_async_event(scsi_qla_host_t *ha, uint16_t *mb)
        }
 }
+static void
+qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, void *data)
+{
+        fc_port_t *fcport = data;
+        if (fcport->ha->max_q_depth <= sdev->queue_depth)
+                return;
+        if (sdev->ordered_tags)
+                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
+                    sdev->queue_depth + 1);
+        else
+                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG,
+                    sdev->queue_depth + 1);
+        fcport->last_ramp_up = jiffies;
+        DEBUG2(qla_printk(KERN_INFO, fcport->ha,
+            "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
+            fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun,
+            sdev->queue_depth));
+}
+static void
+qla2x00_adjust_sdev_qdepth_down(struct scsi_device *sdev, void *data)
+{
+        fc_port_t *fcport = data;
+        if (!scsi_track_queue_full(sdev, sdev->queue_depth - 1))
+                return;
+        DEBUG2(qla_printk(KERN_INFO, fcport->ha,
+            "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
+            fcport->ha->host_no, sdev->channel, sdev->id, sdev->lun,
+            sdev->queue_depth));
+}
+static inline void
+qla2x00_ramp_up_queue_depth(scsi_qla_host_t *ha, srb_t *sp)
+{
+        fc_port_t *fcport;
+        struct scsi_device *sdev;
+        sdev = sp->cmd->device;
+        if (sdev->queue_depth >= ha->max_q_depth)
+                return;
+        fcport = sp->fcport;
+        if (time_before(jiffies,
+            fcport->last_ramp_up + ql2xqfullrampup * HZ))
+                return;
+        if (time_before(jiffies,
+            fcport->last_queue_full + ql2xqfullrampup * HZ))
+                return;
+        spin_unlock_irq(&ha->hardware_lock);
+        starget_for_each_device(sdev->sdev_target, fcport,
+            qla2x00_adjust_sdev_qdepth_up);
+        spin_lock_irq(&ha->hardware_lock);
+}
 /**
 * qla2x00_process_completed_request() - Process a Fast Post response.
 * @ha: SCSI driver HA context
@@ -624,6 +687,8 @@ qla2x00_process_completed_request(struct scsi_qla_host *ha, uint32_t index)
                /* Save ISP completion status */
                sp->cmd->result = DID_OK << 16;
+                qla2x00_ramp_up_queue_depth(ha, sp);
                qla2x00_sp_compl(ha, sp);
        } else {
                DEBUG2(printk("scsi(%ld): Invalid ISP SCSI completion handle\n",
@@ -823,6 +888,7 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
         */
        switch (comp_status) {
        case CS_COMPLETE:
+        case CS_QUEUE_FULL:
                if (scsi_status == 0) {
                        cp->result = DID_OK << 16;
                        break;
@@ -849,6 +915,20 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
                }
                cp->result = DID_OK << 16 | lscsi_status;
+                if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
+                        DEBUG2(printk(KERN_INFO
+                            "scsi(%ld): QUEUE FULL status detected "
+                            "0x%x-0x%x.\n", ha->host_no, comp_status,
+                            scsi_status));
+                        /* Adjust queue depth for all luns on the port. */
+                        fcport->last_queue_full = jiffies;
+                        spin_unlock_irq(&ha->hardware_lock);
+                        starget_for_each_device(cp->device->sdev_target,
+                            fcport, qla2x00_adjust_sdev_qdepth_down);
+                        spin_lock_irq(&ha->hardware_lock);
+                        break;
+                }
                if (lscsi_status != SS_CHECK_CONDITION)
                        break;
@@ -1066,17 +1146,6 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
                        qla2x00_mark_device_lost(ha, fcport, 1, 1);
                break;
-        case CS_QUEUE_FULL:
-                DEBUG2(printk(KERN_INFO
-                    "scsi(%ld): QUEUE FULL status detected 0x%x-0x%x.\n",
-                    ha->host_no, comp_status, scsi_status));
-                /* SCSI Mid-Layer handles device queue full */
-                cp->result = DID_OK << 16 | lscsi_status;
-                break;
        default:
                DEBUG3(printk("scsi(%ld): Error detected (unknown status) "
                    "0x%x-0x%x.\n", ha->host_no, comp_status, scsi_status));
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 3f20d765563e..208607be78c7 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -61,9 +61,9 @@ MODULE_PARM_DESC(ql2xallocfwdump,
                "during HBA initialization.  Memory allocation requirements "
                "vary by ISP type.  Default is 1 - allocate memory.");
-int qla2_extended_error_logging;
+int ql2xextended_error_logging;
-module_param(qla2_extended_error_logging, int, S_IRUGO|S_IRUSR);
+module_param(ql2xextended_error_logging, int, S_IRUGO|S_IRUSR);
-MODULE_PARM_DESC(qla2_extended_error_logging,
+MODULE_PARM_DESC(ql2xextended_error_logging,
                "Option to enable extended error logging, "
                "Default is 0 - no logging. 1 - log errors.");
@@ -77,6 +77,19 @@ MODULE_PARM_DESC(ql2xfdmienable,
                "Enables FDMI registratons "
                "Default is 0 - no FDMI. 1 - perfom FDMI.");
+#define MAX_Q_DEPTH    32
+static int ql2xmaxqdepth = MAX_Q_DEPTH;
+module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(ql2xmaxqdepth,
+                "Maximum queue depth to report for target devices.");
+int ql2xqfullrampup = 120;
+module_param(ql2xqfullrampup, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(ql2xqfullrampup,
+                "Number of seconds to wait to begin to ramp-up the queue "
+                "depth for a device after a queue-full condition has been "
+                "detected.  Default is 120 seconds.");
 /*
 * SCSI host template entry points
 */
@@ -1104,9 +1117,9 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
        struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
        if (sdev->tagged_supported)
-                scsi_activate_tcq(sdev, 32);
+                scsi_activate_tcq(sdev, ha->max_q_depth);
        else
-                scsi_deactivate_tcq(sdev, 32);
+                scsi_deactivate_tcq(sdev, ha->max_q_depth);
        rport->dev_loss_tmo = ha->port_down_retry_count + 5;
@@ -1413,6 +1426,10 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
        ha->link_data_rate = PORT_SPEED_UNKNOWN;
        ha->optrom_size = OPTROM_SIZE_2300;
+        ha->max_q_depth = MAX_Q_DEPTH;
+        if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU)
+                ha->max_q_depth = ql2xmaxqdepth;
        /* Assign ISP specific operations. */
        ha->isp_ops.pci_config          = qla2100_pci_config;
        ha->isp_ops.reset_chip          = qla2x00_reset_chip;
@@ -1712,8 +1729,10 @@ qla2x00_free_device(scsi_qla_host_t *ha)
        if (ha->eft)
                qla2x00_trace_control(ha, TC_DISABLE, 0, 0);
+        ha->flags.online = 0;
        /* Stop currently executing firmware. */
-        qla2x00_stop_firmware(ha);
+        qla2x00_try_to_stop_firmware(ha);
        /* turn-off interrupts on the card */
        if (ha->interrupts_on)
@@ -1721,8 +1740,6 @@ qla2x00_free_device(scsi_qla_host_t *ha)
        qla2x00_mem_free(ha);
-        ha->flags.online = 0;
        /* Detach interrupts */
        if (ha->host->irq)
                free_irq(ha->host->irq, ha);
@@ -2697,7 +2714,7 @@ qla2x00_module_init(void)
        /* Derive version string. */
        strcpy(qla2x00_version_str, QLA2XXX_VERSION);
-        if (qla2_extended_error_logging)
+        if (ql2xextended_error_logging)
                strcat(qla2x00_version_str, "-debug");
        qla2xxx_transport_template =
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index e57bf45a3393..1fa0bce6b24e 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
 * Driver version
 */
-#define QLA2XXX_VERSION      "8.01.07-k2"
+#define QLA2XXX_VERSION      "8.01.07-k3"
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    1
diff --git a/drivers/scsi/qla4xxx/ql4_dbg.h b/drivers/scsi/qla4xxx/ql4_dbg.h
index 3e99dcfd5a9f..d861c3b411c8 100644
--- a/drivers/scsi/qla4xxx/ql4_dbg.h
+++ b/drivers/scsi/qla4xxx/ql4_dbg.h
@@ -22,14 +22,14 @@
 #endif
 #if defined(QL_DEBUG_LEVEL_2)
-#define DEBUG2(x)      do {if(qla4_extended_error_logging == 2) x;} while (0);
+#define DEBUG2(x)      do {if(ql4xextended_error_logging == 2) x;} while (0);
 #define DEBUG2_3(x)   do {x;} while (0);
 #else                           /*  */
 #define DEBUG2(x)       do {} while (0);
 #endif                          /*  */
 #if defined(QL_DEBUG_LEVEL_3)
-#define DEBUG3(x)      do {if(qla4_extended_error_logging == 3) x;} while (0);
+#define DEBUG3(x)      do {if(ql4xextended_error_logging == 3) x;} while (0);
 #else                           /*  */
 #define DEBUG3(x)       do {} while (0);
 #if !defined(QL_DEBUG_LEVEL_2)
diff --git a/drivers/scsi/qla4xxx/ql4_glbl.h b/drivers/scsi/qla4xxx/ql4_glbl.h
index 2c803edf2de8..1b221ff0f6f7 100644
--- a/drivers/scsi/qla4xxx/ql4_glbl.h
+++ b/drivers/scsi/qla4xxx/ql4_glbl.h
@@ -72,7 +72,7 @@ int qla4xxx_reinitialize_ddb_list(struct scsi_qla_host * ha);
 int qla4xxx_process_ddb_changed(struct scsi_qla_host * ha,
                                uint32_t fw_ddb_index, uint32_t state);
-extern int qla4_extended_error_logging;
+extern int ql4xextended_error_logging;
 extern int ql4xdiscoverywait;
 extern int ql4xdontresethba;
 #endif                          /* _QLA4x_GBL_H */
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index ef82399c0858..b721dc5dd711 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -701,7 +701,7 @@ void qla4xxx_get_conn_event_log(struct scsi_qla_host * ha)
        DEBUG3(printk("scsi%ld: Connection Event Log Dump (%d entries):\n",
                      ha->host_no, num_valid_entries));
-        if (qla4_extended_error_logging == 3) {
+        if (ql4xextended_error_logging == 3) {
                if (oldest_entry == 0) {
                        /* Circular Buffer has not wrapped around */
                        for (i=0; i < num_valid_entries; i++) {
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 178fcddcfd81..5b8db6109536 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -34,9 +34,9 @@ MODULE_PARM_DESC(ql4xdontresethba,
                 " default it will reset hba :0"
                 " set to 1 to avoid resetting HBA");
-int qla4_extended_error_logging = 0; /* 0 = off, 1 = log errors */
+int ql4xextended_error_logging = 0; /* 0 = off, 1 = log errors */
-module_param(qla4_extended_error_logging, int, S_IRUGO | S_IRUSR);
+module_param(ql4xextended_error_logging, int, S_IRUGO | S_IRUSR);
-MODULE_PARM_DESC(qla4_extended_error_logging,
+MODULE_PARM_DESC(ql4xextended_error_logging,
                 "Option to enable extended error logging, "
                 "Default is 0 - no logging, 1 - debug logging");
@@ -1714,7 +1714,7 @@ static int __init qla4xxx_module_init(void)
        /* Derive version string. */
        strcpy(qla4xxx_version_str, QLA4XXX_DRIVER_VERSION);
-        if (qla4_extended_error_logging)
+        if (ql4xextended_error_logging)
                strcat(qla4xxx_version_str, "-debug");
        qla4xxx_scsi_transport =
@@ -1724,13 +1724,13 @@ static int __init qla4xxx_module_init(void)
                goto release_srb_cache;
        }
-        printk(KERN_INFO "QLogic iSCSI HBA Driver\n");
        ret = pci_register_driver(&qla4xxx_pci_driver);
        if (ret)
                goto unregister_transport;
        printk(KERN_INFO "QLogic iSCSI HBA Driver\n");
        return 0;
 unregister_transport:
        iscsi_unregister_transport(&qla4xxx_iscsi_transport);
 release_srb_cache:
diff --git a/drivers/scsi/qlogicfas408.c b/drivers/scsi/qlogicfas408.c
index e0725353c99c..2e7db18f5aef 100644
--- a/drivers/scsi/qlogicfas408.c
+++ b/drivers/scsi/qlogicfas408.c
@@ -209,7 +209,7 @@ static int ql_wai(struct qlogicfas408_priv *priv)
 *      caller must hold host lock
 */
-static void ql_icmd(Scsi_Cmnd * cmd)
+static void ql_icmd(struct scsi_cmnd *cmd)
 {
        struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
        int     qbase = priv->qbase;
@@ -256,7 +256,7 @@ static void ql_icmd(Scsi_Cmnd * cmd)
 *      Process scsi command - usually after interrupt 
 */
-static unsigned int ql_pcmd(Scsi_Cmnd * cmd)
+static unsigned int ql_pcmd(struct scsi_cmnd *cmd)
 {
        unsigned int i, j;
        unsigned long k;
@@ -407,7 +407,7 @@ static unsigned int ql_pcmd(Scsi_Cmnd * cmd)
 static void ql_ihandl(void *dev_id)
 {
-        Scsi_Cmnd *icmd;
+        struct scsi_cmnd *icmd;
        struct Scsi_Host *host = dev_id;
        struct qlogicfas408_priv *priv = get_priv_by_host(host);
        int qbase = priv->qbase;
@@ -447,7 +447,8 @@ irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id)
 *      Queued command
 */
-int qlogicfas408_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
+int qlogicfas408_queuecommand(struct scsi_cmnd *cmd,
+                              void (*done) (struct scsi_cmnd *))
 {
        struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
        if (scmd_id(cmd) == priv->qinitid) {
@@ -470,9 +471,8 @@ int qlogicfas408_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 *      Return bios parameters 
 */
-int qlogicfas408_biosparam(struct scsi_device * disk,
+int qlogicfas408_biosparam(struct scsi_device *disk, struct block_device *dev,
-                        struct block_device *dev,
+                           sector_t capacity, int ip[])
-                        sector_t capacity, int ip[])
 {
 /* This should mimic the DOS Qlogic driver's behavior exactly */
        ip[0] = 0x40;
@@ -494,7 +494,7 @@ int qlogicfas408_biosparam(struct scsi_device * disk,
 *      Abort a command in progress
 */
 
-int qlogicfas408_abort(Scsi_Cmnd * cmd)
+int qlogicfas408_abort(struct scsi_cmnd *cmd)
 {
        struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
        priv->qabort = 1;
@@ -508,7 +508,7 @@ int qlogicfas408_abort(Scsi_Cmnd * cmd)
 *      the PCMCIA qlogic_stub code. This wants fixing
 */
-int qlogicfas408_bus_reset(Scsi_Cmnd * cmd)
+int qlogicfas408_bus_reset(struct scsi_cmnd *cmd)
 {
        struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
        unsigned long flags;
diff --git a/drivers/scsi/qlogicfas408.h b/drivers/scsi/qlogicfas408.h
index 8fd5555c75b1..260626427a32 100644
--- a/drivers/scsi/qlogicfas408.h
+++ b/drivers/scsi/qlogicfas408.h
@@ -75,15 +75,15 @@
 /*----------------------------------------------------------------*/
 struct qlogicfas408_priv {
-         int            qbase;          /* Port */
+        int qbase;              /* Port */
-         int            qinitid;        /* initiator ID */
+        int qinitid;            /* initiator ID */
-         int            qabort;         /* Flag to cause an abort */
+        int qabort;             /* Flag to cause an abort */
-         int            qlirq;          /* IRQ being used */
+        int qlirq;              /* IRQ being used */
-         int            int_type;       /* type of irq, 2 for ISA board, 0 for PCMCIA */
+        int int_type;           /* type of irq, 2 for ISA board, 0 for PCMCIA */
-         char           qinfo[80];      /* description */
+        char qinfo[80];         /* description */
-         Scsi_Cmnd      *qlcmd;         /* current command being processed */
+        struct scsi_cmnd *qlcmd;        /* current command being processed */
-         struct Scsi_Host *shost;       /* pointer back to host */
+        struct Scsi_Host *shost;        /* pointer back to host */
-         struct qlogicfas408_priv *next; /* next private struct */
+        struct qlogicfas408_priv *next; /* next private struct */
 };
 /* The qlogic card uses two register maps - These macros select which one */
@@ -103,12 +103,13 @@ struct qlogicfas408_priv {
 #define get_priv_by_host(x) (struct qlogicfas408_priv *)&((x)->hostdata[0])
 irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id);
-int qlogicfas408_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *));
+int qlogicfas408_queuecommand(struct scsi_cmnd * cmd,
+                              void (*done) (struct scsi_cmnd *));
 int qlogicfas408_biosparam(struct scsi_device * disk,
-                        struct block_device *dev,
+                           struct block_device *dev,
-                        sector_t capacity, int ip[]);
+                           sector_t capacity, int ip[]);
-int qlogicfas408_abort(Scsi_Cmnd * cmd);
+int qlogicfas408_abort(struct scsi_cmnd * cmd);
-int qlogicfas408_bus_reset(Scsi_Cmnd * cmd);
+int qlogicfas408_bus_reset(struct scsi_cmnd * cmd);
 const char *qlogicfas408_info(struct Scsi_Host *host);
 int qlogicfas408_get_chip_type(int qbase, int int_type);
 void qlogicfas408_setup(int qbase, int id, int int_type);
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 9c0f35820e3e..30ee3d72c021 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -52,7 +52,7 @@
 #include "scsi_debug.h"
 #define SCSI_DEBUG_VERSION "1.80"
-static const char * scsi_debug_version_date = "20060914";
+static const char * scsi_debug_version_date = "20061018";
 /* Additional Sense Code (ASC) used */
 #define NO_ADDITIONAL_SENSE 0x0
@@ -254,6 +254,8 @@ static int resp_requests(struct scsi_cmnd * SCpnt,
                         struct sdebug_dev_info * devip);
 static int resp_start_stop(struct scsi_cmnd * scp,
                           struct sdebug_dev_info * devip);
+static int resp_report_tgtpgs(struct scsi_cmnd * scp,
+                              struct sdebug_dev_info * devip);
 static int resp_readcap(struct scsi_cmnd * SCpnt,
                        struct sdebug_dev_info * devip);
 static int resp_readcap16(struct scsi_cmnd * SCpnt,
@@ -287,9 +289,9 @@ static void __init sdebug_build_parts(unsigned char * ramp);
 static void __init init_all_queued(void);
 static void stop_all_queued(void);
 static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
-static int inquiry_evpd_83(unsigned char * arr, int target_dev_id,
+static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
-                           int dev_id_num, const char * dev_id_str,
+                           int target_dev_id, int dev_id_num,
-                           int dev_id_str_len);
+                           const char * dev_id_str, int dev_id_str_len);
 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id);
 static int do_create_driverfs_files(void);
 static void do_remove_driverfs_files(void);
@@ -422,6 +424,15 @@ int scsi_debug_queuecommand(struct scsi_cmnd * SCpnt, done_funct_t done)
                }
                errsts = resp_readcap16(SCpnt, devip);
                break;
+        case MAINTENANCE_IN:
+                if (MI_REPORT_TARGET_PGS != cmd[1]) {
+                        mk_sense_buffer(devip, ILLEGAL_REQUEST,
+                                        INVALID_OPCODE, 0);
+                        errsts = check_condition_result;
+                        break;
+                }
+                errsts = resp_report_tgtpgs(SCpnt, devip);
+                break;
        case READ_16:
        case READ_12:
        case READ_10:
@@ -665,8 +676,9 @@ static const char * inq_vendor_id = "Linux   ";
 static const char * inq_product_id = "scsi_debug      ";
 static const char * inq_product_rev = "0004";
-static int inquiry_evpd_83(unsigned char * arr, int target_dev_id,
+static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
-                           int dev_id_num, const char * dev_id_str,
+                           int target_dev_id, int dev_id_num,
+                           const char * dev_id_str,
                           int dev_id_str_len)
 {
        int num, port_a;
@@ -720,6 +732,15 @@ static int inquiry_evpd_83(unsigned char * arr, int target_dev_id,
        arr[num++] = (port_a >> 16) & 0xff;
        arr[num++] = (port_a >> 8) & 0xff;
        arr[num++] = port_a & 0xff;
+        /* NAA-5, Target port group identifier */
+        arr[num++] = 0x61;      /* proto=sas, binary */
+        arr[num++] = 0x95;      /* piv=1, target port group id */
+        arr[num++] = 0x0;
+        arr[num++] = 0x4;
+        arr[num++] = 0;
+        arr[num++] = 0;
+        arr[num++] = (port_group_id >> 8) & 0xff;
+        arr[num++] = port_group_id & 0xff;
        /* NAA-5, Target device identifier */
        arr[num++] = 0x61;      /* proto=sas, binary */
        arr[num++] = 0xa3;      /* piv=1, target device, naa */
@@ -928,12 +949,12 @@ static int resp_inquiry(struct scsi_cmnd * scp, int target,
                        struct sdebug_dev_info * devip)
 {
        unsigned char pq_pdt;
-        unsigned char arr[SDEBUG_MAX_INQ_ARR_SZ];
+        unsigned char * arr;
        unsigned char *cmd = (unsigned char *)scp->cmnd;
-        int alloc_len, n;
+        int alloc_len, n, ret;
        alloc_len = (cmd[3] << 8) + cmd[4];
-        memset(arr, 0, SDEBUG_MAX_INQ_ARR_SZ);
+        arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_KERNEL);
        if (devip->wlun)
                pq_pdt = 0x1e;  /* present, wlun */
        else if (scsi_debug_no_lun_0 && (0 == devip->lun))
@@ -944,12 +965,15 @@ static int resp_inquiry(struct scsi_cmnd * scp, int target,
        if (0x2 & cmd[1]) {  /* CMDDT bit set */
                mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
                                0);
+                kfree(arr);
                return check_condition_result;
        } else if (0x1 & cmd[1]) {  /* EVPD bit set */
-                int lu_id_num, target_dev_id, len;
+                int lu_id_num, port_group_id, target_dev_id, len;
                char lu_id_str[6];
                int host_no = devip->sdbg_host->shost->host_no;
                
+                port_group_id = (((host_no + 1) & 0x7f) << 8) +
+                    (devip->channel & 0x7f);
                if (0 == scsi_debug_vpd_use_hostno)
                        host_no = 0;
                lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
@@ -977,8 +1001,9 @@ static int resp_inquiry(struct scsi_cmnd * scp, int target,
                        memcpy(&arr[4], lu_id_str, len);
                } else if (0x83 == cmd[2]) { /* device identification */
                        arr[1] = cmd[2];        /*sanity */
-                        arr[3] = inquiry_evpd_83(&arr[4], target_dev_id,
+                        arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
-                                                 lu_id_num, lu_id_str, len);
+                                                 target_dev_id, lu_id_num,
+                                                 lu_id_str, len);
                } else if (0x84 == cmd[2]) { /* Software interface ident. */
                        arr[1] = cmd[2];        /*sanity */
                        arr[3] = inquiry_evpd_84(&arr[4]);
@@ -1012,17 +1037,22 @@ static int resp_inquiry(struct scsi_cmnd * scp, int target,
                        /* Illegal request, invalid field in cdb */
                        mk_sense_buffer(devip, ILLEGAL_REQUEST,
                                        INVALID_FIELD_IN_CDB, 0);
+                        kfree(arr);
                        return check_condition_result;
                }
                len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
-                return fill_from_dev_buffer(scp, arr,
+                ret = fill_from_dev_buffer(scp, arr,
                            min(len, SDEBUG_MAX_INQ_ARR_SZ));
+                kfree(arr);
+                return ret;
        }
        /* drops through here for a standard inquiry */
        arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0;     /* Removable disk */
        arr[2] = scsi_debug_scsi_level;
        arr[3] = 2;    /* response_data_format==2 */
        arr[4] = SDEBUG_LONG_INQ_SZ - 5;
+        if (0 == scsi_debug_vpd_use_hostno)
+                arr[5] = 0x10; /* claim: implicit TGPS */
        arr[6] = 0x10; /* claim: MultiP */
        /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
        arr[7] = 0xa; /* claim: LINKED + CMDQUE */
@@ -1039,8 +1069,10 @@ static int resp_inquiry(struct scsi_cmnd * scp, int target,
                arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
        }
        arr[n++] = 0xc; arr[n++] = 0xf;  /* SAS-1.1 rev 10 */
-        return fill_from_dev_buffer(scp, arr,
+        ret = fill_from_dev_buffer(scp, arr,
                            min(alloc_len, SDEBUG_LONG_INQ_SZ));
+        kfree(arr);
+        return ret;
 }
 static int resp_requests(struct scsi_cmnd * scp,
@@ -1171,6 +1203,87 @@ static int resp_readcap16(struct scsi_cmnd * scp,
                                    min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
 }
+#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
+static int resp_report_tgtpgs(struct scsi_cmnd * scp,
+                              struct sdebug_dev_info * devip)
+{
+        unsigned char *cmd = (unsigned char *)scp->cmnd;
+        unsigned char * arr;
+        int host_no = devip->sdbg_host->shost->host_no;
+        int n, ret, alen, rlen;
+        int port_group_a, port_group_b, port_a, port_b;
+        alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
+                + cmd[9]);
+        arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_KERNEL);
+        /*
+         * EVPD page 0x88 states we have two ports, one
+         * real and a fake port with no device connected.
+         * So we create two port groups with one port each
+         * and set the group with port B to unavailable.
+         */
+        port_a = 0x1; /* relative port A */
+        port_b = 0x2; /* relative port B */
+        port_group_a = (((host_no + 1) & 0x7f) << 8) +
+            (devip->channel & 0x7f);
+        port_group_b = (((host_no + 1) & 0x7f) << 8) +
+            (devip->channel & 0x7f) + 0x80;
+        /*
+         * The asymmetric access state is cycled according to the host_id.
+         */
+        n = 4;
+        if (0 == scsi_debug_vpd_use_hostno) {
+            arr[n++] = host_no % 3; /* Asymm access state */
+            arr[n++] = 0x0F; /* claim: all states are supported */
+        } else {
+            arr[n++] = 0x0; /* Active/Optimized path */
+            arr[n++] = 0x01; /* claim: only support active/optimized paths */
+        }
+        arr[n++] = (port_group_a >> 8) & 0xff;
+        arr[n++] = port_group_a & 0xff;
+        arr[n++] = 0;    /* Reserved */
+        arr[n++] = 0;    /* Status code */
+        arr[n++] = 0;    /* Vendor unique */
+        arr[n++] = 0x1;  /* One port per group */
+        arr[n++] = 0;    /* Reserved */
+        arr[n++] = 0;    /* Reserved */
+        arr[n++] = (port_a >> 8) & 0xff;
+        arr[n++] = port_a & 0xff;
+        arr[n++] = 3;    /* Port unavailable */
+        arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
+        arr[n++] = (port_group_b >> 8) & 0xff;
+        arr[n++] = port_group_b & 0xff;
+        arr[n++] = 0;    /* Reserved */
+        arr[n++] = 0;    /* Status code */
+        arr[n++] = 0;    /* Vendor unique */
+        arr[n++] = 0x1;  /* One port per group */
+        arr[n++] = 0;    /* Reserved */
+        arr[n++] = 0;    /* Reserved */
+        arr[n++] = (port_b >> 8) & 0xff;
+        arr[n++] = port_b & 0xff;
+        rlen = n - 4;
+        arr[0] = (rlen >> 24) & 0xff;
+        arr[1] = (rlen >> 16) & 0xff;
+        arr[2] = (rlen >> 8) & 0xff;
+        arr[3] = rlen & 0xff;
+        /*
+         * Return the smallest value of either
+         * - The allocated length
+         * - The constructed command length
+         * - The maximum array size
+         */
+        rlen = min(alen,n);
+        ret = fill_from_dev_buffer(scp, arr,
+                                   min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
+        kfree(arr);
+        return ret;
+}
 /* <<Following mode page info copied from ST318451LW>> */
 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 743f67ed7640..d2c02df12fdc 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1084,7 +1084,7 @@ static void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd)
 {
        struct request *req = cmd->request;
-        BUG_ON(sizeof(req->cmd) > sizeof(cmd->cmnd));
+        BUILD_BUG_ON(sizeof(req->cmd) > sizeof(cmd->cmnd));
        memcpy(cmd->cmnd, req->cmd, sizeof(cmd->cmnd));
        cmd->cmd_len = req->cmd_len;
        if (!req->data_len)
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index e7fe565b96de..e1a91665d1c2 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -192,6 +192,7 @@ static CLASS_DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost
 shost_rd_attr(unique_id, "%u\n");
 shost_rd_attr(host_busy, "%hu\n");
 shost_rd_attr(cmd_per_lun, "%hd\n");
+shost_rd_attr(can_queue, "%hd\n");
 shost_rd_attr(sg_tablesize, "%hu\n");
 shost_rd_attr(unchecked_isa_dma, "%d\n");
 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
@@ -200,6 +201,7 @@ static struct class_device_attribute *scsi_sysfs_shost_attrs[] = {
        &class_device_attr_unique_id,
        &class_device_attr_host_busy,
        &class_device_attr_cmd_per_lun,
+        &class_device_attr_can_queue,
        &class_device_attr_sg_tablesize,
        &class_device_attr_unchecked_isa_dma,
        &class_device_attr_proc_name,
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 7b0019cccce3..2d3baa99ca25 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -21,7 +21,6 @@
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 #include <linux/module.h>
-#include <linux/mempool.h>
 #include <linux/mutex.h>
 #include <net/tcp.h>
 #include <scsi/scsi.h>
@@ -149,30 +148,6 @@ static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
 static struct sock *nls;
 static DEFINE_MUTEX(rx_queue_mutex);
-struct mempool_zone {
-        mempool_t *pool;
-        atomic_t allocated;
-        int size;
-        int hiwat;
-        struct list_head freequeue;
-        spinlock_t freelock;
-};
-static struct mempool_zone *z_reply;
-/*
- * Z_MAX_* - actual mempool size allocated at the mempool_zone_init() time
- * Z_HIWAT_* - zone's high watermark when if_error bit will be set to -ENOMEM
- *             so daemon will notice OOM on NETLINK tranposrt level and will
- *             be able to predict or change operational behavior
- */
-#define Z_MAX_REPLY     8
-#define Z_HIWAT_REPLY   6
-#define Z_MAX_PDU       8
-#define Z_HIWAT_PDU     6
-#define Z_MAX_ERROR     16
-#define Z_HIWAT_ERROR   12
 static LIST_HEAD(sesslist);
 static DEFINE_SPINLOCK(sesslock);
 static LIST_HEAD(connlist);
@@ -414,59 +389,11 @@ int iscsi_destroy_session(struct iscsi_cls_session *session)
 }
 EXPORT_SYMBOL_GPL(iscsi_destroy_session);
-static void mempool_zone_destroy(struct mempool_zone *zp)
-{
-        mempool_destroy(zp->pool);
-        kfree(zp);
-}
-static void*
-mempool_zone_alloc_skb(gfp_t gfp_mask, void *pool_data)
-{
-        struct mempool_zone *zone = pool_data;
-        return alloc_skb(zone->size, gfp_mask);
-}
-static void
-mempool_zone_free_skb(void *element, void *pool_data)
-{
-        kfree_skb(element);
-}
-static struct mempool_zone *
-mempool_zone_init(unsigned max, unsigned size, unsigned hiwat)
-{
-        struct mempool_zone *zp;
-        zp = kzalloc(sizeof(*zp), GFP_KERNEL);
-        if (!zp)
-                return NULL;
-        zp->size = size;
-        zp->hiwat = hiwat;
-        INIT_LIST_HEAD(&zp->freequeue);
-        spin_lock_init(&zp->freelock);
-        atomic_set(&zp->allocated, 0);
-        zp->pool = mempool_create(max, mempool_zone_alloc_skb,
-                                  mempool_zone_free_skb, zp);
-        if (!zp->pool) {
-                kfree(zp);
-                return NULL;
-        }
-        return zp;
-}
 static void iscsi_conn_release(struct device *dev)
 {
        struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
        struct device *parent = conn->dev.parent;
-        mempool_zone_destroy(conn->z_pdu);
-        mempool_zone_destroy(conn->z_error);
        kfree(conn);
        put_device(parent);
 }
@@ -476,31 +403,6 @@ static int iscsi_is_conn_dev(const struct device *dev)
        return dev->release == iscsi_conn_release;
 }
-static int iscsi_create_event_pools(struct iscsi_cls_conn *conn)
-{
-        conn->z_pdu = mempool_zone_init(Z_MAX_PDU,
-                        NLMSG_SPACE(sizeof(struct iscsi_uevent) +
-                                    sizeof(struct iscsi_hdr) +
-                                    DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH),
-                        Z_HIWAT_PDU);
-        if (!conn->z_pdu) {
-                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not allocate "
-                           "pdu zone for new conn\n");
-                return -ENOMEM;
-        }
-        conn->z_error = mempool_zone_init(Z_MAX_ERROR,
-                        NLMSG_SPACE(sizeof(struct iscsi_uevent)),
-                        Z_HIWAT_ERROR);
-        if (!conn->z_error) {
-                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not allocate "
-                           "error zone for new conn\n");
-                mempool_zone_destroy(conn->z_pdu);
-                return -ENOMEM;
-        }
-        return 0;
-}
 /**
 * iscsi_create_conn - create iscsi class connection
 * @session: iscsi cls session
@@ -533,12 +435,9 @@ iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
        conn->transport = transport;
        conn->cid = cid;
-        if (iscsi_create_event_pools(conn))
-                goto free_conn;
        /* this is released in the dev's release function */
        if (!get_device(&session->dev))
-                goto free_conn_pools;
+                goto free_conn;
        snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
                 session->sid, cid);
@@ -555,8 +454,6 @@ iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
 release_parent_ref:
        put_device(&session->dev);
-free_conn_pools:
 free_conn:
        kfree(conn);
        return NULL;
@@ -599,81 +496,31 @@ iscsi_if_transport_lookup(struct iscsi_transport *tt)
        return NULL;
 }
-static inline struct list_head *skb_to_lh(struct sk_buff *skb)
-{
-        return (struct list_head *)&skb->cb;
-}
-static void
-mempool_zone_complete(struct mempool_zone *zone)
-{
-        unsigned long flags;
-        struct list_head *lh, *n;
-        spin_lock_irqsave(&zone->freelock, flags);
-        list_for_each_safe(lh, n, &zone->freequeue) {
-                struct sk_buff *skb = (struct sk_buff *)((char *)lh -
-                                offsetof(struct sk_buff, cb));
-                if (!skb_shared(skb)) {
-                        list_del(skb_to_lh(skb));
-                        mempool_free(skb, zone->pool);
-                        atomic_dec(&zone->allocated);
-                }
-        }
-        spin_unlock_irqrestore(&zone->freelock, flags);
-}
-static struct sk_buff*
-mempool_zone_get_skb(struct mempool_zone *zone)
-{
-        struct sk_buff *skb;
-        skb = mempool_alloc(zone->pool, GFP_ATOMIC);
-        if (skb)
-                atomic_inc(&zone->allocated);
-        return skb;
-}
 static int
-iscsi_broadcast_skb(struct mempool_zone *zone, struct sk_buff *skb, gfp_t gfp)
+iscsi_broadcast_skb(struct sk_buff *skb, gfp_t gfp)
 {
-        unsigned long flags;
        int rc;
-        skb_get(skb);
        rc = netlink_broadcast(nls, skb, 0, 1, gfp);
        if (rc < 0) {
-                mempool_free(skb, zone->pool);
                printk(KERN_ERR "iscsi: can not broadcast skb (%d)\n", rc);
                return rc;
        }
-        spin_lock_irqsave(&zone->freelock, flags);
-        INIT_LIST_HEAD(skb_to_lh(skb));
-        list_add(skb_to_lh(skb), &zone->freequeue);
-        spin_unlock_irqrestore(&zone->freelock, flags);
        return 0;
 }
 static int
-iscsi_unicast_skb(struct mempool_zone *zone, struct sk_buff *skb, int pid)
+iscsi_unicast_skb(struct sk_buff *skb, int pid)
 {
-        unsigned long flags;
        int rc;
-        skb_get(skb);
        rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT);
        if (rc < 0) {
-                mempool_free(skb, zone->pool);
                printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
                return rc;
        }
-        spin_lock_irqsave(&zone->freelock, flags);
-        INIT_LIST_HEAD(skb_to_lh(skb));
-        list_add(skb_to_lh(skb), &zone->freequeue);
-        spin_unlock_irqrestore(&zone->freelock, flags);
        return 0;
 }
@@ -692,9 +539,7 @@ int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
        if (!priv)
                return -EINVAL;
-        mempool_zone_complete(conn->z_pdu);
+        skb = alloc_skb(len, GFP_ATOMIC);
-        skb = mempool_zone_get_skb(conn->z_pdu);
        if (!skb) {
                iscsi_conn_error(conn, ISCSI_ERR_CONN_FAILED);
                dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
@@ -707,15 +552,13 @@ int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
        memset(ev, 0, sizeof(*ev));
        ev->transport_handle = iscsi_handle(conn->transport);
        ev->type = ISCSI_KEVENT_RECV_PDU;
-        if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
-                ev->iferror = -ENOMEM;
        ev->r.recv_req.cid = conn->cid;
        ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
        pdu = (char*)ev + sizeof(*ev);
        memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
        memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
-        return iscsi_unicast_skb(conn->z_pdu, skb, priv->daemon_pid);
+        return iscsi_unicast_skb(skb, priv->daemon_pid);
 }
 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
@@ -731,9 +574,7 @@ void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
        if (!priv)
                return;
-        mempool_zone_complete(conn->z_error);
+        skb = alloc_skb(len, GFP_ATOMIC);
-        skb = mempool_zone_get_skb(conn->z_error);
        if (!skb) {
                dev_printk(KERN_ERR, &conn->dev, "iscsi: gracefully ignored "
                          "conn error (%d)\n", error);
@@ -744,13 +585,11 @@ void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
        ev = NLMSG_DATA(nlh);
        ev->transport_handle = iscsi_handle(conn->transport);
        ev->type = ISCSI_KEVENT_CONN_ERROR;
-        if (atomic_read(&conn->z_error->allocated) >= conn->z_error->hiwat)
-                ev->iferror = -ENOMEM;
        ev->r.connerror.error = error;
        ev->r.connerror.cid = conn->cid;
        ev->r.connerror.sid = iscsi_conn_get_sid(conn);
-        iscsi_broadcast_skb(conn->z_error, skb, GFP_ATOMIC);
+        iscsi_broadcast_skb(skb, GFP_ATOMIC);
        dev_printk(KERN_INFO, &conn->dev, "iscsi: detected conn error (%d)\n",
                   error);
@@ -767,9 +606,7 @@ iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
        int flags = multi ? NLM_F_MULTI : 0;
        int t = done ? NLMSG_DONE : type;
-        mempool_zone_complete(z_reply);
+        skb = alloc_skb(len, GFP_ATOMIC);
-        skb = mempool_zone_get_skb(z_reply);
        /*
         * FIXME:
         * user is supposed to react on iferror == -ENOMEM;
@@ -780,7 +617,7 @@ iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
        nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
        nlh->nlmsg_flags = flags;
        memcpy(NLMSG_DATA(nlh), payload, size);
-        return iscsi_unicast_skb(z_reply, skb, pid);
+        return iscsi_unicast_skb(skb, pid);
 }
 static int
@@ -810,9 +647,7 @@ iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
        do {
                int actual_size;
-                mempool_zone_complete(conn->z_pdu);
+                skbstat = alloc_skb(len, GFP_ATOMIC);
-                skbstat = mempool_zone_get_skb(conn->z_pdu);
                if (!skbstat) {
                        dev_printk(KERN_ERR, &conn->dev, "iscsi: can not "
                                   "deliver stats: OOM\n");
@@ -825,8 +660,6 @@ iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
                memset(evstat, 0, sizeof(*evstat));
                evstat->transport_handle = iscsi_handle(conn->transport);
                evstat->type = nlh->nlmsg_type;
-                if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
-                        evstat->iferror = -ENOMEM;
                evstat->u.get_stats.cid =
                        ev->u.get_stats.cid;
                evstat->u.get_stats.sid =
@@ -845,7 +678,7 @@ iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
                skb_trim(skbstat, NLMSG_ALIGN(actual_size));
                nlhstat->nlmsg_len = actual_size;
-                err = iscsi_unicast_skb(conn->z_pdu, skbstat, priv->daemon_pid);
+                err = iscsi_unicast_skb(skbstat, priv->daemon_pid);
        } while (err < 0 && err != -ECONNREFUSED);
        return err;
@@ -876,9 +709,7 @@ int iscsi_if_destroy_session_done(struct iscsi_cls_conn *conn)
        session = iscsi_dev_to_session(conn->dev.parent);
        shost = iscsi_session_to_shost(session);
-        mempool_zone_complete(conn->z_pdu);
+        skb = alloc_skb(len, GFP_KERNEL);
-        skb = mempool_zone_get_skb(conn->z_pdu);
        if (!skb) {
                dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
                          "session creation event\n");
@@ -896,7 +727,7 @@ int iscsi_if_destroy_session_done(struct iscsi_cls_conn *conn)
         * this will occur if the daemon is not up, so we just warn
         * the user and when the daemon is restarted it will handle it
         */
-        rc = iscsi_broadcast_skb(conn->z_pdu, skb, GFP_KERNEL);
+        rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
        if (rc < 0)
                dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
                          "session destruction event. Check iscsi daemon\n");
@@ -939,9 +770,7 @@ int iscsi_if_create_session_done(struct iscsi_cls_conn *conn)
        session = iscsi_dev_to_session(conn->dev.parent);
        shost = iscsi_session_to_shost(session);
-        mempool_zone_complete(conn->z_pdu);
+        skb = alloc_skb(len, GFP_KERNEL);
-        skb = mempool_zone_get_skb(conn->z_pdu);
        if (!skb) {
                dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
                          "session creation event\n");
@@ -959,7 +788,7 @@ int iscsi_if_create_session_done(struct iscsi_cls_conn *conn)
         * this will occur if the daemon is not up, so we just warn
         * the user and when the daemon is restarted it will handle it
         */
-        rc = iscsi_broadcast_skb(conn->z_pdu, skb, GFP_KERNEL);
+        rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
        if (rc < 0)
                dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
                          "session creation event. Check iscsi daemon\n");
@@ -1278,9 +1107,6 @@ iscsi_if_rx(struct sock *sk, int len)
                                err = iscsi_if_send_reply(
                                        NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
                                        nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
-                                if (atomic_read(&z_reply->allocated) >=
-                                                z_reply->hiwat)
-                                        ev->iferror = -ENOMEM;
                        } while (err < 0 && err != -ECONNREFUSED);
                        skb_pull(skb, rlen);
                }
@@ -1584,32 +1410,6 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
 }
 EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
-static int
-iscsi_rcv_nl_event(struct notifier_block *this, unsigned long event, void *ptr)
-{
-        struct netlink_notify *n = ptr;
-        if (event == NETLINK_URELEASE &&
-            n->protocol == NETLINK_ISCSI && n->pid) {
-                struct iscsi_cls_conn *conn;
-                unsigned long flags;
-                mempool_zone_complete(z_reply);
-                spin_lock_irqsave(&connlock, flags);
-                list_for_each_entry(conn, &connlist, conn_list) {
-                        mempool_zone_complete(conn->z_error);
-                        mempool_zone_complete(conn->z_pdu);
-                }
-                spin_unlock_irqrestore(&connlock, flags);
-        }
-        return NOTIFY_DONE;
-}
-static struct notifier_block iscsi_nl_notifier = {
-        .notifier_call  = iscsi_rcv_nl_event,
-};
 static __init int iscsi_transport_init(void)
 {
        int err;
@@ -1633,25 +1433,15 @@ static __init int iscsi_transport_init(void)
        if (err)
                goto unregister_conn_class;
-        err = netlink_register_notifier(&iscsi_nl_notifier);
-        if (err)
-                goto unregister_session_class;
        nls = netlink_kernel_create(NETLINK_ISCSI, 1, iscsi_if_rx,
                        THIS_MODULE);
        if (!nls) {
                err = -ENOBUFS;
-                goto unregister_notifier;
+                goto unregister_session_class;
        }
-        z_reply = mempool_zone_init(Z_MAX_REPLY,
+        return 0;
-                NLMSG_SPACE(sizeof(struct iscsi_uevent)), Z_HIWAT_REPLY);
-        if (z_reply)
-                return 0;
-        sock_release(nls->sk_socket);
-unregister_notifier:
-        netlink_unregister_notifier(&iscsi_nl_notifier);
 unregister_session_class:
        transport_class_unregister(&iscsi_session_class);
 unregister_conn_class:
@@ -1665,9 +1455,7 @@ unregister_transport_class:
 static void __exit iscsi_transport_exit(void)
 {
-        mempool_zone_destroy(z_reply);
        sock_release(nls->sk_socket);
-        netlink_unregister_notifier(&iscsi_nl_notifier);
        transport_class_unregister(&iscsi_connection_class);
        transport_class_unregister(&iscsi_session_class);
        transport_class_unregister(&iscsi_host_class);
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 3babdc76b3fb..e1a52c525ed4 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -1177,7 +1177,10 @@ static int st_open(struct inode *inode, struct file *filp)
                goto err_out;
        if ((filp->f_flags & O_NONBLOCK) == 0 &&
            retval != CHKRES_READY) {
-                retval = (-EIO);
+                if (STp->ready == NO_TAPE)
+                        retval = (-ENOMEDIUM);
+                else
+                        retval = (-EIO);
                goto err_out;
        }
        return 0;
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index 5ec5af8e3379..3b3f3050a877 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -266,8 +266,8 @@ static struct scsi_host_template *the_template = NULL;
        (struct NCR5380_hostdata *)(in)->hostdata
 #define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
-#define NEXT(cmd)       ((Scsi_Cmnd *)((cmd)->host_scribble))
+#define NEXT(cmd)       ((struct scsi_cmnd *)((cmd)->host_scribble))
-#define NEXTADDR(cmd)   ((Scsi_Cmnd **)&((cmd)->host_scribble))
+#define NEXTADDR(cmd)   ((struct scsi_cmnd **)&((cmd)->host_scribble))
 #define HOSTNO          instance->host_no
 #define H_NO(cmd)       (cmd)->device->host->host_no
@@ -360,7 +360,7 @@ static void __init init_tags( void )
 * conditions.
 */ 
-static int is_lun_busy( Scsi_Cmnd *cmd, int should_be_tagged )
+static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
 {
    SETUP_HOSTDATA(cmd->device->host);
@@ -384,7 +384,7 @@ static int is_lun_busy( Scsi_Cmnd *cmd, int should_be_tagged )
 * untagged.
 */
-static void cmd_get_tag( Scsi_Cmnd *cmd, int should_be_tagged )
+static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
 {
    SETUP_HOSTDATA(cmd->device->host);
@@ -416,7 +416,7 @@ static void cmd_get_tag( Scsi_Cmnd *cmd, int should_be_tagged )
 * unlock the LUN.
 */
-static void cmd_free_tag( Scsi_Cmnd *cmd )
+static void cmd_free_tag(struct scsi_cmnd *cmd)
 {
    SETUP_HOSTDATA(cmd->device->host);
@@ -460,18 +460,18 @@ static void free_all_tags( void )
 /*
- * Function: void merge_contiguous_buffers( Scsi_Cmnd *cmd )
+ * Function: void merge_contiguous_buffers(struct scsi_cmnd *cmd)
 *
 * Purpose: Try to merge several scatter-gather requests into one DMA
 *    transfer. This is possible if the scatter buffers lie on
 *    physical contiguous addresses.
 *
- * Parameters: Scsi_Cmnd *cmd
+ * Parameters: struct scsi_cmnd *cmd
 *    The command to work on. The first scatter buffer's data are
 *    assumed to be already transfered into ptr/this_residual.
 */
-static void merge_contiguous_buffers( Scsi_Cmnd *cmd )
+static void merge_contiguous_buffers(struct scsi_cmnd *cmd)
 {
    unsigned long endaddr;
 #if (NDEBUG & NDEBUG_MERGING)
@@ -501,15 +501,15 @@ static void merge_contiguous_buffers( Scsi_Cmnd *cmd )
 }
 /*
- * Function : void initialize_SCp(Scsi_Cmnd *cmd)
+ * Function : void initialize_SCp(struct scsi_cmnd *cmd)
 *
 * Purpose : initialize the saved data pointers for cmd to point to the 
 *      start of the buffer.
 *
- * Inputs : cmd - Scsi_Cmnd structure to have pointers reset.
+ * Inputs : cmd - struct scsi_cmnd structure to have pointers reset.
 */
-static __inline__ void initialize_SCp(Scsi_Cmnd *cmd)
+static __inline__ void initialize_SCp(struct scsi_cmnd *cmd)
 {
    /* 
     * Initialize the Scsi Pointer field so that all of the commands in the 
@@ -753,14 +753,15 @@ static void NCR5380_print_status (struct Scsi_Host *instance)
  do { if (pos + strlen(fmt) + 20 /* slop */ < buffer + length) \
         pos += sprintf(pos, fmt , ## args); } while(0)
 static
-char *lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length);
+char *lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, char *pos, char *buffer,
+                       int length);
-static int NCR5380_proc_info (struct Scsi_Host *instance, char *buffer, char **start,
+static int NCR5380_proc_info(struct Scsi_Host *instance, char *buffer,
-                       off_t offset, int length, int inout)
+                             char **start, off_t offset, int length, int inout)
 {
    char *pos = buffer;
    struct NCR5380_hostdata *hostdata;
-    Scsi_Cmnd *ptr;
+    struct scsi_cmnd *ptr;
    unsigned long flags;
    off_t begin = 0;
 #define check_offset()                          \
@@ -784,18 +785,19 @@ static int NCR5380_proc_info (struct Scsi_Host *instance, char *buffer, char **s
    if (!hostdata->connected)
        SPRINTF("scsi%d: no currently connected command\n", HOSTNO);
    else
-        pos = lprint_Scsi_Cmnd ((Scsi_Cmnd *) hostdata->connected,
+        pos = lprint_Scsi_Cmnd ((struct scsi_cmnd *) hostdata->connected,
                                pos, buffer, length);
    SPRINTF("scsi%d: issue_queue\n", HOSTNO);
    check_offset();
-    for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; ptr = NEXT(ptr)) {
+    for (ptr = (struct scsi_cmnd *) hostdata->issue_queue; ptr; ptr = NEXT(ptr))
+    {
        pos = lprint_Scsi_Cmnd (ptr, pos, buffer, length);
        check_offset();
    }
    SPRINTF("scsi%d: disconnected_queue\n", HOSTNO);
    check_offset();
-    for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
+    for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr;
         ptr = NEXT(ptr)) {
        pos = lprint_Scsi_Cmnd (ptr, pos, buffer, length);
        check_offset();
@@ -810,8 +812,8 @@ static int NCR5380_proc_info (struct Scsi_Host *instance, char *buffer, char **s
    return length;
 }
-static char *
+static char *lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, char *pos, char *buffer,
-lprint_Scsi_Cmnd (Scsi_Cmnd *cmd, char *pos, char *buffer, int length)
+                              int length)
 {
    int i, s;
    unsigned char *command;
@@ -888,8 +890,8 @@ static int NCR5380_init (struct Scsi_Host *instance, int flags)
 }
 /* 
- * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd, 
+ * Function : int NCR5380_queue_command (struct scsi_cmnd *cmd,
- *      void (*done)(Scsi_Cmnd *)) 
+ *      void (*done)(struct scsi_cmnd *))
 *
 * Purpose :  enqueues a SCSI command
 *
@@ -906,10 +908,11 @@ static int NCR5380_init (struct Scsi_Host *instance, int flags)
 */
 /* Only make static if a wrapper function is used */
-static int NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
+static int NCR5380_queue_command(struct scsi_cmnd *cmd,
+                                 void (*done)(struct scsi_cmnd *))
 {
    SETUP_HOSTDATA(cmd->device->host);
-    Scsi_Cmnd *tmp;
+    struct scsi_cmnd *tmp;
    unsigned long flags;
 #if (NDEBUG & NDEBUG_NO_WRITE)
@@ -990,7 +993,7 @@ static int NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
        NEXT(cmd) = hostdata->issue_queue;
        hostdata->issue_queue = cmd;
    } else {
-        for (tmp = (Scsi_Cmnd *)hostdata->issue_queue;
+        for (tmp = (struct scsi_cmnd *)hostdata->issue_queue;
             NEXT(tmp); tmp = NEXT(tmp))
            ;
        LIST(cmd, tmp);
@@ -1030,7 +1033,7 @@ static int NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
    
 static void NCR5380_main (void *bl)
 {
-    Scsi_Cmnd *tmp, *prev;
+    struct scsi_cmnd *tmp, *prev;
    struct Scsi_Host *instance = first_instance;
    struct NCR5380_hostdata *hostdata = HOSTDATA(instance);
    int done;
@@ -1073,12 +1076,12 @@ static void NCR5380_main (void *bl)
             * for a target that's not busy.
             */
 #if (NDEBUG & NDEBUG_LISTS)
-            for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL;
+            for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL;
                 tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
                ;
            if ((tmp == prev) && tmp) printk(" LOOP\n");/* else printk("\n");*/
 #endif
-            for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, 
+            for (tmp = (struct scsi_cmnd *) hostdata->issue_queue,
                 prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp) ) {
 #if (NDEBUG & NDEBUG_LISTS)
@@ -1339,7 +1342,8 @@ static irqreturn_t NCR5380_intr (int irq, void *dev_id)
 }
 #ifdef NCR5380_STATS
-static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd* cmd)
+static void collect_stats(struct NCR5380_hostdata *hostdata,
+                          struct scsi_cmnd *cmd)
 {
 # ifdef NCR5380_STAT_LIMIT
    if (cmd->request_bufflen > NCR5380_STAT_LIMIT)
@@ -1365,8 +1369,8 @@ static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd* cmd)
 #endif
 /* 
- * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, 
+ * Function : int NCR5380_select(struct Scsi_Host *instance,
- *      int tag);
+ *                               struct scsi_cmnd *cmd, int tag);
 *
 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
 *      including ARBITRATION, SELECTION, and initial message out for 
@@ -1395,7 +1399,8 @@ static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd* cmd)
 *              cmd->result host byte set to DID_BAD_TARGET.
 */
-static int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
+static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd,
+                          int tag)
 {
    SETUP_HOSTDATA(instance);
    unsigned char tmp[3], phase;
@@ -1985,7 +1990,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance)
 #endif
    unsigned char *data;
    unsigned char phase, tmp, extended_msg[10], old_phase=0xff;
-    Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
+    struct scsi_cmnd *cmd = (struct scsi_cmnd *) hostdata->connected;
 #ifdef SUN3_SCSI_VME
    dregs->csr |= CSR_INTR;
@@ -2272,7 +2277,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance)
                        local_irq_save(flags);
                        LIST(cmd,hostdata->issue_queue);
                        NEXT(cmd) = hostdata->issue_queue;
-                        hostdata->issue_queue = (Scsi_Cmnd *) cmd;
+                        hostdata->issue_queue = (struct scsi_cmnd *) cmd;
                        local_irq_restore(flags);
                        QU_PRINTK("scsi%d: REQUEST SENSE added to head of "
                                  "issue queue\n", H_NO(cmd));
@@ -2502,7 +2507,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance)
 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
 *
 * Purpose : does reselection, initializing the instance->connected 
- *      field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q 
+ *      field to point to the struct scsi_cmnd for which the I_T_L or I_T_L_Q
 *      nexus has been reestablished,
 *      
 * Inputs : instance - this instance of the NCR5380.
@@ -2521,7 +2526,7 @@ static void NCR5380_reselect (struct Scsi_Host *instance)
    unsigned char tag;
 #endif
    unsigned char msg[3];
-    Scsi_Cmnd *tmp = NULL, *prev;
+    struct scsi_cmnd *tmp = NULL, *prev;
 /*    unsigned long flags; */
    /*
@@ -2577,7 +2582,7 @@ static void NCR5380_reselect (struct Scsi_Host *instance)
     * just reestablished, and remove it from the disconnected queue.
     */
-    for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL; 
+    for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL;
         tmp; prev = tmp, tmp = NEXT(tmp) ) {
        if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
 #ifdef SUPPORT_TAGS
@@ -2668,11 +2673,11 @@ static void NCR5380_reselect (struct Scsi_Host *instance)
 /*
- * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
+ * Function : int NCR5380_abort(struct scsi_cmnd *cmd)
 *
 * Purpose : abort a command
 *
- * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the 
+ * Inputs : cmd - the struct scsi_cmnd to abort, code - code to set the
 *      host byte of the result field to, if zero DID_ABORTED is 
 *      used.
 *
@@ -2684,11 +2689,11 @@ static void NCR5380_reselect (struct Scsi_Host *instance)
 *       called where the loop started in NCR5380_main().
 */
-static int NCR5380_abort (Scsi_Cmnd *cmd)
+static int NCR5380_abort(struct scsi_cmnd *cmd)
 {
    struct Scsi_Host *instance = cmd->device->host;
    SETUP_HOSTDATA(instance);
-    Scsi_Cmnd *tmp, **prev;
+    struct scsi_cmnd *tmp, **prev;
    unsigned long flags;
    printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
@@ -2753,9 +2758,9 @@ static int NCR5380_abort (Scsi_Cmnd *cmd)
 * Case 2 : If the command hasn't been issued yet, we simply remove it 
 *          from the issue queue.
 */
-    for (prev = (Scsi_Cmnd **) &(hostdata->issue_queue), 
+    for (prev = (struct scsi_cmnd **) &(hostdata->issue_queue),
-        tmp = (Scsi_Cmnd *) hostdata->issue_queue;
+        tmp = (struct scsi_cmnd *) hostdata->issue_queue;
-        tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp) )
+        tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp))
        if (cmd == tmp) {
            REMOVE(5, *prev, tmp, NEXT(tmp));
            (*prev) = NEXT(tmp);
@@ -2812,7 +2817,7 @@ static int NCR5380_abort (Scsi_Cmnd *cmd)
 * it from the disconnected queue.
 */
-    for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp;
+    for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp;
         tmp = NEXT(tmp)) 
        if (cmd == tmp) {
            local_irq_restore(flags);
@@ -2826,8 +2831,8 @@ static int NCR5380_abort (Scsi_Cmnd *cmd)
            do_abort (instance);
            local_irq_save(flags);
-            for (prev = (Scsi_Cmnd **) &(hostdata->disconnected_queue), 
+            for (prev = (struct scsi_cmnd **) &(hostdata->disconnected_queue),
-                tmp = (Scsi_Cmnd *) hostdata->disconnected_queue;
+                tmp = (struct scsi_cmnd *) hostdata->disconnected_queue;
                tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp) )
                    if (cmd == tmp) {
                    REMOVE(5, *prev, tmp, NEXT(tmp));
@@ -2868,7 +2873,7 @@ static int NCR5380_abort (Scsi_Cmnd *cmd)
 /* 
- * Function : int NCR5380_bus_reset (Scsi_Cmnd *cmd)
+ * Function : int NCR5380_bus_reset(struct scsi_cmnd *cmd)
 * 
 * Purpose : reset the SCSI bus.
 *
@@ -2876,13 +2881,13 @@ static int NCR5380_abort (Scsi_Cmnd *cmd)
 *
 */ 
-static int NCR5380_bus_reset( Scsi_Cmnd *cmd)
+static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
 {
    SETUP_HOSTDATA(cmd->device->host);
    int           i;
    unsigned long flags;
 #if 1
-    Scsi_Cmnd *connected, *disconnected_queue;
+    struct scsi_cmnd *connected, *disconnected_queue;
 #endif
@@ -2914,9 +2919,9 @@ static int NCR5380_bus_reset( Scsi_Cmnd *cmd)
     * remembered in local variables first.
     */
    local_irq_save(flags);
-    connected = (Scsi_Cmnd *)hostdata->connected;
+    connected = (struct scsi_cmnd *)hostdata->connected;
    hostdata->connected = NULL;
-    disconnected_queue = (Scsi_Cmnd *)hostdata->disconnected_queue;
+    disconnected_queue = (struct scsi_cmnd *)hostdata->disconnected_queue;
    hostdata->disconnected_queue = NULL;
 #ifdef SUPPORT_TAGS
    free_all_tags();
diff --git a/drivers/scsi/sun3_scsi.c b/drivers/scsi/sun3_scsi.c
index e625b4c5833a..d56d85dd9ba0 100644
--- a/drivers/scsi/sun3_scsi.c
+++ b/drivers/scsi/sun3_scsi.c
@@ -119,7 +119,7 @@ module_param(setup_use_tagged_queuing, int, 0);
 static int setup_hostid = -1;
 module_param(setup_hostid, int, 0);
-static Scsi_Cmnd *sun3_dma_setup_done = NULL;
+static struct scsi_cmnd *sun3_dma_setup_done = NULL;
 #define AFTER_RESET_DELAY       (HZ/2)
@@ -521,8 +521,9 @@ static inline unsigned long sun3scsi_dma_residual(struct Scsi_Host *instance)
        return last_residual;
 }
-static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted, Scsi_Cmnd *cmd,
+static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted,
-                                    int write_flag)
+                                                  struct scsi_cmnd *cmd,
+                                                  int write_flag)
 {
        if(blk_fs_request(cmd->request))
                return wanted;
diff --git a/drivers/scsi/sun3_scsi.h b/drivers/scsi/sun3_scsi.h
index 834dab428019..a1103b3e2034 100644
--- a/drivers/scsi/sun3_scsi.h
+++ b/drivers/scsi/sun3_scsi.h
@@ -47,11 +47,12 @@
 #define IOBASE_SUN3_VMESCSI 0xff200000
-static int sun3scsi_abort (Scsi_Cmnd *);
+static int sun3scsi_abort(struct scsi_cmnd *);
 static int sun3scsi_detect (struct scsi_host_template *);
 static const char *sun3scsi_info (struct Scsi_Host *);
-static int sun3scsi_bus_reset(Scsi_Cmnd *);
+static int sun3scsi_bus_reset(struct scsi_cmnd *);
-static int sun3scsi_queue_command (Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
+static int sun3scsi_queue_command(struct scsi_cmnd *,
+                                  void (*done)(struct scsi_cmnd *));
 static int sun3scsi_release (struct Scsi_Host *);
 #ifndef CMD_PER_LUN
diff --git a/drivers/scsi/sun3_scsi_vme.c b/drivers/scsi/sun3_scsi_vme.c
index e8faab16567b..92def310a84c 100644
--- a/drivers/scsi/sun3_scsi_vme.c
+++ b/drivers/scsi/sun3_scsi_vme.c
@@ -84,7 +84,7 @@ module_param(setup_use_tagged_queuing, int, 0);
 static int setup_hostid = -1;
 module_param(setup_hostid, int, 0);
-static Scsi_Cmnd *sun3_dma_setup_done = NULL;
+static struct scsi_cmnd *sun3_dma_setup_done = NULL;
 #define AFTER_RESET_DELAY       (HZ/2)
@@ -455,8 +455,9 @@ static inline unsigned long sun3scsi_dma_residual(struct Scsi_Host *instance)
        return last_residual;
 }
-static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted, Scsi_Cmnd *cmd,
+static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted,
-                                    int write_flag)
+                                                  struct scsi_cmnd *cmd,
+                                                  int write_flag)
 {
        if(blk_fs_request(cmd->request))
                return wanted;
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index d03aa6ce8fe8..fa5382e354be 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -2304,6 +2304,7 @@ static struct scsi_host_template driver_template = {
        .sg_tablesize           = SG_ALL,
        .cmd_per_lun            = 1,
        .use_clustering         = ENABLE_CLUSTERING,
+        .max_sectors            = 0x4000, /* 8MiB = 16 * 1024 * 512 */
 };
 /***********************************************************************
diff --git a/drivers/video/backlight/corgi_bl.c b/drivers/video/backlight/corgi_bl.c
index 2ebbfd95145f..d07ecb53c68b 100644
--- a/drivers/video/backlight/corgi_bl.c
+++ b/drivers/video/backlight/corgi_bl.c
@@ -111,7 +111,7 @@ static struct backlight_properties corgibl_data = {
        .update_status  = corgibl_set_intensity,
 };
-static int __init corgibl_probe(struct platform_device *pdev)
+static int corgibl_probe(struct platform_device *pdev)
 {
        struct corgibl_machinfo *machinfo = pdev->dev.platform_data;
@@ -166,4 +166,4 @@ module_exit(corgibl_exit);
 MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
 MODULE_DESCRIPTION("Corgi Backlight Driver");
-MODULE_LICENSE("GPLv2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/hitfb.c b/drivers/video/hitfb.c
index 3afb472763c0..3dc49424dc75 100644
--- a/drivers/video/hitfb.c
+++ b/drivers/video/hitfb.c
@@ -29,7 +29,6 @@
 #include <asm/io.h>
 #include <asm/hd64461.h>
 #include <asm/cpu/dac.h>
-#include <asm/hp6xx/hp6xx.h>
 #define WIDTH 640
diff --git a/drivers/video/intelfb/intelfbhw.c b/drivers/video/intelfb/intelfbhw.c
index eeeeff9a09eb..a95836839e1e 100644
--- a/drivers/video/intelfb/intelfbhw.c
+++ b/drivers/video/intelfb/intelfbhw.c
@@ -161,7 +161,7 @@ intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size,
                return 1;
        /* Find the bridge device.  It is always 0:0.0 */
-        if (!(bridge_dev = pci_find_slot(0, PCI_DEVFN(0, 0)))) {
+        if (!(bridge_dev = pci_get_bus_and_slot(0, PCI_DEVFN(0, 0)))) {
                ERR_MSG("cannot find bridge device\n");
                return 1;
        }
@@ -169,6 +169,8 @@ intelfbhw_get_memory(struct pci_dev *pdev, int *aperture_size,
        /* Get the fb aperture size and "stolen" memory amount. */
        tmp = 0;
        pci_read_config_word(bridge_dev, INTEL_GMCH_CTRL, &tmp);
+        pci_dev_put(bridge_dev);
        switch (pdev->device) {
        case PCI_DEVICE_ID_INTEL_915G:
        case PCI_DEVICE_ID_INTEL_915GM:
@@ -662,7 +664,7 @@ intelfbhw_print_hw_state(struct intelfb_info *dinfo, struct intelfb_hwstate *hw)
        int index = dinfo->pll_index;
        DBG_MSG("intelfbhw_print_hw_state\n");
-        if (!hw || !dinfo)
+        if (!hw)
                return;
        /* Read in as much of the HW state as possible. */
        printk("hw state dump start\n");