Merge branch 'upstream'

36 files changed, 2856 insertions, 905 deletions

diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
index 2bf723a7b6e6..6f1a83c9d9e0 100644
--- a/drivers/atm/fore200e.c
+++ b/drivers/atm/fore200e.c
@@ -178,14 +178,12 @@ fore200e_irq_itoa(int irq)
 
 
 static void*
-fore200e_kmalloc(int size, int flags)
+fore200e_kmalloc(int size, unsigned int __nocast flags)
 {
-    void* chunk = kmalloc(size, flags);
+    void *chunk = kzalloc(size, flags);
 
-    if (chunk)
-        memset(chunk, 0x00, size);
-    else
-        printk(FORE200E "kmalloc() failed, requested size = %d, flags = 0x%x\n", size, flags);
+    if (!chunk)
+        printk(FORE200E "kmalloc() failed, requested size = %d, flags = 0x%x\n",                        size, flags);
     
     return chunk;
 }
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 95a976c96eb8..70458cb061c6 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -47,7 +47,7 @@ MODULE_PARM_DESC(cards_limit, "Maximum number of graphics cards");
 MODULE_PARM_DESC(debug, "Enable debug output");
 
 module_param_named(cards_limit, drm_cards_limit, int, 0444);
-module_param_named(debug, drm_debug, int, 0666);
+module_param_named(debug, drm_debug, int, 0600);
 
 drm_head_t **drm_heads;
 struct drm_sysfs_class *drm_class;
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c
index bb0b3a8de14b..1422285d537c 100644
--- a/drivers/connector/connector.c
+++ b/drivers/connector/connector.c
@@ -69,7 +69,8 @@ int cn_already_initialized = 0;
  * a new message.
  *
  */
-int cn_netlink_send(struct cn_msg *msg, u32 __group, int gfp_mask)
+int cn_netlink_send(struct cn_msg *msg, u32 __group,
+                    unsigned int __nocast gfp_mask)
 {
         struct cn_callback_entry *__cbq;
         unsigned int size;
diff --git a/drivers/infiniband/hw/mthca/mthca_main.c b/drivers/infiniband/hw/mthca/mthca_main.c
index ffbcd40418d5..23a3f56c7899 100644
--- a/drivers/infiniband/hw/mthca/mthca_main.c
+++ b/drivers/infiniband/hw/mthca/mthca_main.c
@@ -503,6 +503,25 @@ err_free_aux:
         return err;
 }
 
+static void mthca_free_icms(struct mthca_dev *mdev)
+{
+        u8 status;
+
+        mthca_free_icm_table(mdev, mdev->mcg_table.table);
+        if (mdev->mthca_flags & MTHCA_FLAG_SRQ)
+                mthca_free_icm_table(mdev, mdev->srq_table.table);
+        mthca_free_icm_table(mdev, mdev->cq_table.table);
+        mthca_free_icm_table(mdev, mdev->qp_table.rdb_table);
+        mthca_free_icm_table(mdev, mdev->qp_table.eqp_table);
+        mthca_free_icm_table(mdev, mdev->qp_table.qp_table);
+        mthca_free_icm_table(mdev, mdev->mr_table.mpt_table);
+        mthca_free_icm_table(mdev, mdev->mr_table.mtt_table);
+        mthca_unmap_eq_icm(mdev);
+
+        mthca_UNMAP_ICM_AUX(mdev, &status);
+        mthca_free_icm(mdev, mdev->fw.arbel.aux_icm);
+}
+
 static int __devinit mthca_init_arbel(struct mthca_dev *mdev)
 {
         struct mthca_dev_lim        dev_lim;
@@ -580,18 +599,7 @@ static int __devinit mthca_init_arbel(struct mthca_dev *mdev)
         return 0;
 
 err_free_icm:
-        if (mdev->mthca_flags & MTHCA_FLAG_SRQ)
-                mthca_free_icm_table(mdev, mdev->srq_table.table);
-        mthca_free_icm_table(mdev, mdev->cq_table.table);
-        mthca_free_icm_table(mdev, mdev->qp_table.rdb_table);
-        mthca_free_icm_table(mdev, mdev->qp_table.eqp_table);
-        mthca_free_icm_table(mdev, mdev->qp_table.qp_table);
-        mthca_free_icm_table(mdev, mdev->mr_table.mpt_table);
-        mthca_free_icm_table(mdev, mdev->mr_table.mtt_table);
-        mthca_unmap_eq_icm(mdev);
-
-        mthca_UNMAP_ICM_AUX(mdev, &status);
-        mthca_free_icm(mdev, mdev->fw.arbel.aux_icm);
+        mthca_free_icms(mdev);
 
 err_stop_fw:
         mthca_UNMAP_FA(mdev, &status);
@@ -611,18 +619,7 @@ static void mthca_close_hca(struct mthca_dev *mdev)
         mthca_CLOSE_HCA(mdev, 0, &status);
 
         if (mthca_is_memfree(mdev)) {
-                if (mdev->mthca_flags & MTHCA_FLAG_SRQ)
-                        mthca_free_icm_table(mdev, mdev->srq_table.table);
-                mthca_free_icm_table(mdev, mdev->cq_table.table);
-                mthca_free_icm_table(mdev, mdev->qp_table.rdb_table);
-                mthca_free_icm_table(mdev, mdev->qp_table.eqp_table);
-                mthca_free_icm_table(mdev, mdev->qp_table.qp_table);
-                mthca_free_icm_table(mdev, mdev->mr_table.mpt_table);
-                mthca_free_icm_table(mdev, mdev->mr_table.mtt_table);
-                mthca_unmap_eq_icm(mdev);
-
-                mthca_UNMAP_ICM_AUX(mdev, &status);
-                mthca_free_icm(mdev, mdev->fw.arbel.aux_icm);
+                mthca_free_icms(mdev);
 
                 mthca_UNMAP_FA(mdev, &status);
                 mthca_free_icm(mdev, mdev->fw.arbel.fw_icm);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 704f48e0b6a7..6c5bf07489f4 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -474,7 +474,7 @@ err:
         spin_unlock(&priv->lock);
 }
 
-static void path_lookup(struct sk_buff *skb, struct net_device *dev)
+static void ipoib_path_lookup(struct sk_buff *skb, struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(skb->dev);
 
@@ -569,7 +569,7 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         if (skb->dst && skb->dst->neighbour) {
                 if (unlikely(!*to_ipoib_neigh(skb->dst->neighbour))) {
-                        path_lookup(skb, dev);
+                        ipoib_path_lookup(skb, dev);
                         goto out;
                 }
 
diff --git a/drivers/mfd/ucb1x00-core.c b/drivers/mfd/ucb1x00-core.c
index 10f6ce1bc0ab..612564ac6f7b 100644
--- a/drivers/mfd/ucb1x00-core.c
+++ b/drivers/mfd/ucb1x00-core.c
@@ -642,8 +642,6 @@ static void __exit ucb1x00_exit(void)
 module_init(ucb1x00_init);
 module_exit(ucb1x00_exit);
 
-EXPORT_SYMBOL(ucb1x00_class);
-
 EXPORT_SYMBOL(ucb1x00_io_set_dir);
 EXPORT_SYMBOL(ucb1x00_io_write);
 EXPORT_SYMBOL(ucb1x00_io_read);
diff --git a/drivers/mfd/ucb1x00.h b/drivers/mfd/ucb1x00.h
index 6b632644f59a..9c9a647d8b7b 100644
--- a/drivers/mfd/ucb1x00.h
+++ b/drivers/mfd/ucb1x00.h
@@ -106,8 +106,6 @@ struct ucb1x00_irq {
         void (*fn)(int, void *);
 };
 
-extern struct class ucb1x00_class;
-
 struct ucb1x00 {
         spinlock_t              lock;
         struct mcp              *mcp;
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 2a908c4690a7..c748b0e16419 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1655,7 +1655,7 @@ config LAN_SAA9730
 
 config NET_POCKET
         bool "Pocket and portable adapters"
-        depends on NET_ETHERNET && ISA
+        depends on NET_ETHERNET && PARPORT
         ---help---
           Cute little network (Ethernet) devices which attach to the parallel
           port ("pocket adapters"), commonly used with laptops. If you have
@@ -1679,7 +1679,7 @@ config NET_POCKET
 
 config ATP
         tristate "AT-LAN-TEC/RealTek pocket adapter support"
-        depends on NET_POCKET && ISA && X86
+        depends on NET_POCKET && PARPORT && X86
         select CRC32
         ---help---
           This is a network (Ethernet) device which attaches to your parallel
@@ -1694,7 +1694,7 @@ config ATP
 
 config DE600
         tristate "D-Link DE600 pocket adapter support"
-        depends on NET_POCKET && ISA
+        depends on NET_POCKET && PARPORT
         ---help---
           This is a network (Ethernet) device which attaches to your parallel
           port. Read <file:Documentation/networking/DLINK.txt> as well as the
@@ -1709,7 +1709,7 @@ config DE600
 
 config DE620
         tristate "D-Link DE620 pocket adapter support"
-        depends on NET_POCKET && ISA
+        depends on NET_POCKET && PARPORT
         ---help---
           This is a network (Ethernet) device which attaches to your parallel
           port. Read <file:Documentation/networking/DLINK.txt> as well as the
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index bf81cd45e4d4..f0a5b772a386 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -487,6 +487,8 @@
  *        * Added xmit_hash_policy_layer34()
  *      - Modified by Jay Vosburgh <fubar@us.ibm.com> to also support mode 4.
  *        Set version to 2.6.3.
+ * 2005/09/26 - Jay Vosburgh <fubar@us.ibm.com>
+ *      - Removed backwards compatibility for old ifenslaves.  Version 2.6.4.
  */
 
 //#define BONDING_DEBUG 1
@@ -595,14 +597,7 @@ static int arp_ip_count	= 0;
 static int bond_mode    = BOND_MODE_ROUNDROBIN;
 static int xmit_hashtype= BOND_XMIT_POLICY_LAYER2;
 static int lacp_fast    = 0;
-static int app_abi_ver  = 0;
-static int orig_app_abi_ver = -1; /* This is used to save the first ABI version
-                                   * we receive from the application. Once set,
-                                   * it won't be changed, and the module will
-                                   * refuse to enslave/release interfaces if the
-                                   * command comes from an application using
-                                   * another ABI version.
-                                   */
+
 struct bond_parm_tbl {
         char *modename;
         int mode;
@@ -1294,12 +1289,13 @@ static void bond_mc_list_destroy(struct bonding *bond)
 /*
  * Copy all the Multicast addresses from src to the bonding device dst
  */
-static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond, int gpf_flag)
+static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond,
+                             unsigned int __nocast gfp_flag)
 {
         struct dev_mc_list *dmi, *new_dmi;
 
         for (dmi = mc_list; dmi; dmi = dmi->next) {
-                new_dmi = kmalloc(sizeof(struct dev_mc_list), gpf_flag);
+                new_dmi = kmalloc(sizeof(struct dev_mc_list), gfp_flag);
 
                 if (!new_dmi) {
                         /* FIXME: Potential memory leak !!! */
@@ -1702,51 +1698,29 @@ static int bond_enslave(struct net_device *bond_dev, struct net_device *slave_de
                 }
         }
 
-        if (app_abi_ver >= 1) {
-                /* The application is using an ABI, which requires the
-                 * slave interface to be closed.
-                 */
-                if ((slave_dev->flags & IFF_UP)) {
-                        printk(KERN_ERR DRV_NAME
-                               ": Error: %s is up\n",
-                               slave_dev->name);
-                        res = -EPERM;
-                        goto err_undo_flags;
-                }
-
-                if (slave_dev->set_mac_address == NULL) {
-                        printk(KERN_ERR DRV_NAME
-                               ": Error: The slave device you specified does "
-                               "not support setting the MAC address.\n");
-                        printk(KERN_ERR
-                               "Your kernel likely does not support slave "
-                               "devices.\n");
+        /*
+         * Old ifenslave binaries are no longer supported.  These can
+         * be identified with moderate accurary by the state of the slave:
+         * the current ifenslave will set the interface down prior to
+         * enslaving it; the old ifenslave will not.
+         */
+        if ((slave_dev->flags & IFF_UP)) {
+                printk(KERN_ERR DRV_NAME ": %s is up. "
+                       "This may be due to an out of date ifenslave.\n",
+                       slave_dev->name);
+                res = -EPERM;
+                goto err_undo_flags;
+        }
 
-                        res = -EOPNOTSUPP;
-                        goto err_undo_flags;
-                }
-        } else {
-                /* The application is not using an ABI, which requires the
-                 * slave interface to be open.
-                 */
-                if (!(slave_dev->flags & IFF_UP)) {
-                        printk(KERN_ERR DRV_NAME
-                               ": Error: %s is not running\n",
-                               slave_dev->name);
-                        res = -EINVAL;
-                        goto err_undo_flags;
-                }
+        if (slave_dev->set_mac_address == NULL) {
+                printk(KERN_ERR DRV_NAME
+                       ": Error: The slave device you specified does "
+                       "not support setting the MAC address.\n");
+                printk(KERN_ERR
+                       "Your kernel likely does not support slave devices.\n");
 
-                if ((bond->params.mode == BOND_MODE_8023AD) ||
-                    (bond->params.mode == BOND_MODE_TLB)    ||
-                    (bond->params.mode == BOND_MODE_ALB)) {
-                        printk(KERN_ERR DRV_NAME
-                               ": Error: to use %s mode, you must upgrade "
-                               "ifenslave.\n",
-                               bond_mode_name(bond->params.mode));
-                        res = -EOPNOTSUPP;
-                        goto err_undo_flags;
-                }
+                res = -EOPNOTSUPP;
+                goto err_undo_flags;
         }
 
         new_slave = kmalloc(sizeof(struct slave), GFP_KERNEL);
@@ -1762,41 +1736,36 @@ static int bond_enslave(struct net_device *bond_dev, struct net_device *slave_de
          */
         new_slave->original_flags = slave_dev->flags;
 
-        if (app_abi_ver >= 1) {
-                /* save slave's original ("permanent") mac address for
-                 * modes that needs it, and for restoring it upon release,
-                 * and then set it to the master's address
-                 */
-                memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
+        /*
+         * Save slave's original ("permanent") mac address for modes
+         * that need it, and for restoring it upon release, and then
+         * set it to the master's address
+         */
+        memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
 
-                /* set slave to master's mac address
-                 * The application already set the master's
-                 * mac address to that of the first slave
-                 */
-                memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
-                addr.sa_family = slave_dev->type;
-                res = dev_set_mac_address(slave_dev, &addr);
-                if (res) {
-                        dprintk("Error %d calling set_mac_address\n", res);
-                        goto err_free;
-                }
+        /*
+         * Set slave to master's mac address.  The application already
+         * set the master's mac address to that of the first slave
+         */
+        memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
+        addr.sa_family = slave_dev->type;
+        res = dev_set_mac_address(slave_dev, &addr);
+        if (res) {
+                dprintk("Error %d calling set_mac_address\n", res);
+                goto err_free;
+        }
 
-                /* open the slave since the application closed it */
-                res = dev_open(slave_dev);
-                if (res) {
-                        dprintk("Openning slave %s failed\n", slave_dev->name);
-                        goto err_restore_mac;
-                }
+        /* open the slave since the application closed it */
+        res = dev_open(slave_dev);
+        if (res) {
+                dprintk("Openning slave %s failed\n", slave_dev->name);
+                goto err_restore_mac;
         }
 
         res = netdev_set_master(slave_dev, bond_dev);
         if (res) {
                 dprintk("Error %d calling netdev_set_master\n", res);
-                if (app_abi_ver < 1) {
-                        goto err_free;
-                } else {
-                        goto err_close;
-                }
+                goto err_close;
         }
 
         new_slave->dev = slave_dev;
@@ -1997,39 +1966,6 @@ static int bond_enslave(struct net_device *bond_dev, struct net_device *slave_de
 
         write_unlock_bh(&bond->lock);
 
-        if (app_abi_ver < 1) {
-                /*
-                 * !!! This is to support old versions of ifenslave.
-                 * We can remove this in 2.5 because our ifenslave takes
-                 * care of this for us.
-                 * We check to see if the master has a mac address yet.
-                 * If not, we'll give it the mac address of our slave device.
-                 */
-                int ndx = 0;
-
-                for (ndx = 0; ndx < bond_dev->addr_len; ndx++) {
-                        dprintk("Checking ndx=%d of bond_dev->dev_addr\n",
-                                ndx);
-                        if (bond_dev->dev_addr[ndx] != 0) {
-                                dprintk("Found non-zero byte at ndx=%d\n",
-                                        ndx);
-                                break;
-                        }
-                }
-
-                if (ndx == bond_dev->addr_len) {
-                        /*
-                         * We got all the way through the address and it was
-                         * all 0's.
-                         */
-                        dprintk("%s doesn't have a MAC address yet.  \n",
-                                bond_dev->name);
-                        dprintk("Going to give assign it from %s.\n",
-                                slave_dev->name);
-                        bond_sethwaddr(bond_dev, slave_dev);
-                }
-        }
-
         printk(KERN_INFO DRV_NAME
                ": %s: enslaving %s as a%s interface with a%s link.\n",
                bond_dev->name, slave_dev->name,
@@ -2227,12 +2163,10 @@ static int bond_release(struct net_device *bond_dev, struct net_device *slave_de
         /* close slave before restoring its mac address */
         dev_close(slave_dev);
 
-        if (app_abi_ver >= 1) {
-                /* restore original ("permanent") mac address */
-                memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
-                addr.sa_family = slave_dev->type;
-                dev_set_mac_address(slave_dev, &addr);
-        }
+        /* restore original ("permanent") mac address */
+        memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
+        addr.sa_family = slave_dev->type;
+        dev_set_mac_address(slave_dev, &addr);
 
         /* restore the original state of the
          * IFF_NOARP flag that might have been
@@ -2320,12 +2254,10 @@ static int bond_release_all(struct net_device *bond_dev)
                 /* close slave before restoring its mac address */
                 dev_close(slave_dev);
 
-                if (app_abi_ver >= 1) {
-                        /* restore original ("permanent") mac address*/
-                        memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
-                        addr.sa_family = slave_dev->type;
-                        dev_set_mac_address(slave_dev, &addr);
-                }
+                /* restore original ("permanent") mac address*/
+                memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
+                addr.sa_family = slave_dev->type;
+                dev_set_mac_address(slave_dev, &addr);
 
                 /* restore the original state of the IFF_NOARP flag that might have
                  * been set by bond_set_slave_inactive_flags()
@@ -2423,57 +2355,6 @@ static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_devi
         return res;
 }
 
-static int bond_ethtool_ioctl(struct net_device *bond_dev, struct ifreq *ifr)
-{
-        struct ethtool_drvinfo info;
-        void __user *addr = ifr->ifr_data;
-        uint32_t cmd;
-
-        if (get_user(cmd, (uint32_t __user *)addr)) {
-                return -EFAULT;
-        }
-
-        switch (cmd) {
-        case ETHTOOL_GDRVINFO:
-                if (copy_from_user(&info, addr, sizeof(info))) {
-                        return -EFAULT;
-                }
-
-                if (strcmp(info.driver, "ifenslave") == 0) {
-                        int new_abi_ver;
-                        char *endptr;
-
-                        new_abi_ver = simple_strtoul(info.fw_version,
-                                                     &endptr, 0);
-                        if (*endptr) {
-                                printk(KERN_ERR DRV_NAME
-                                       ": Error: got invalid ABI "
-                                       "version from application\n");
-
-                                return -EINVAL;
-                        }
-
-                        if (orig_app_abi_ver == -1) {
-                                orig_app_abi_ver  = new_abi_ver;
-                        }
-
-                        app_abi_ver = new_abi_ver;
-                }
-
-                strncpy(info.driver,  DRV_NAME, 32);
-                strncpy(info.version, DRV_VERSION, 32);
-                snprintf(info.fw_version, 32, "%d", BOND_ABI_VERSION);
-
-                if (copy_to_user(addr, &info, sizeof(info))) {
-                        return -EFAULT;
-                }
-
-                return 0;
-        default:
-                return -EOPNOTSUPP;
-        }
-}
-
 static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
 {
         struct bonding *bond = bond_dev->priv;
@@ -3442,16 +3323,11 @@ static void bond_info_show_slave(struct seq_file *seq, const struct slave *slave
         seq_printf(seq, "Link Failure Count: %d\n",
                    slave->link_failure_count);
 
-        if (app_abi_ver >= 1) {
-                seq_printf(seq,
-                           "Permanent HW addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
-                           slave->perm_hwaddr[0],
-                           slave->perm_hwaddr[1],
-                           slave->perm_hwaddr[2],
-                           slave->perm_hwaddr[3],
-                           slave->perm_hwaddr[4],
-                           slave->perm_hwaddr[5]);
-        }
+        seq_printf(seq,
+                   "Permanent HW addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
+                   slave->perm_hwaddr[0], slave->perm_hwaddr[1],
+                   slave->perm_hwaddr[2], slave->perm_hwaddr[3],
+                   slave->perm_hwaddr[4], slave->perm_hwaddr[5]);
 
         if (bond->params.mode == BOND_MODE_8023AD) {
                 const struct aggregator *agg
@@ -4010,15 +3886,12 @@ static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd
         struct ifslave k_sinfo;
         struct ifslave __user *u_sinfo = NULL;
         struct mii_ioctl_data *mii = NULL;
-        int prev_abi_ver = orig_app_abi_ver;
         int res = 0;
 
         dprintk("bond_ioctl: master=%s, cmd=%d\n",
                 bond_dev->name, cmd);
 
         switch (cmd) {
-        case SIOCETHTOOL:
-                return bond_ethtool_ioctl(bond_dev, ifr);
         case SIOCGMIIPHY:
                 mii = if_mii(ifr);
                 if (!mii) {
@@ -4090,21 +3963,6 @@ static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd
                 return -EPERM;
         }
 
-        if (orig_app_abi_ver == -1) {
-                /* no orig_app_abi_ver was provided yet, so we'll use the
-                 * current one from now on, even if it's 0
-                 */
-                orig_app_abi_ver = app_abi_ver;
-
-        } else if (orig_app_abi_ver != app_abi_ver) {
-                printk(KERN_ERR DRV_NAME
-                       ": Error: already using ifenslave ABI version %d; to "
-                       "upgrade ifenslave to version %d, you must first "
-                       "reload bonding.\n",
-                       orig_app_abi_ver, app_abi_ver);
-                return -EINVAL;
-        }
-
         slave_dev = dev_get_by_name(ifr->ifr_slave);
 
         dprintk("slave_dev=%p: \n", slave_dev);
@@ -4137,14 +3995,6 @@ static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd
                 dev_put(slave_dev);
         }
 
-        if (res < 0) {
-                /* The ioctl failed, so there's no point in changing the
-                 * orig_app_abi_ver. We'll restore it's value just in case
-                 * we've changed it earlier in this function.
-                 */
-                orig_app_abi_ver = prev_abi_ver;
-        }
-
         return res;
 }
 
@@ -4578,9 +4428,18 @@ static inline void bond_set_mode_ops(struct bonding *bond, int mode)
         }
 }
 
+static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
+                                    struct ethtool_drvinfo *drvinfo)
+{
+        strncpy(drvinfo->driver, DRV_NAME, 32);
+        strncpy(drvinfo->version, DRV_VERSION, 32);
+        snprintf(drvinfo->fw_version, 32, "%d", BOND_ABI_VERSION);
+}
+
 static struct ethtool_ops bond_ethtool_ops = {
         .get_tx_csum            = ethtool_op_get_tx_csum,
         .get_sg                 = ethtool_op_get_sg,
+        .get_drvinfo            = bond_ethtool_get_drvinfo,
 };
 
 /*
diff --git a/drivers/net/bonding/bonding.h b/drivers/net/bonding/bonding.h
index 388196980862..bbf9da8af624 100644
--- a/drivers/net/bonding/bonding.h
+++ b/drivers/net/bonding/bonding.h
@@ -40,8 +40,8 @@
 #include "bond_3ad.h"
 #include "bond_alb.h"
 
-#define DRV_VERSION     "2.6.3"
-#define DRV_RELDATE     "June 8, 2005"
+#define DRV_VERSION     "2.6.4"
+#define DRV_RELDATE     "September 26, 2005"
 #define DRV_NAME        "bonding"
 #define DRV_DESCRIPTION "Ethernet Channel Bonding Driver"
 
diff --git a/drivers/net/ibm_emac/ibm_emac_core.c b/drivers/net/ibm_emac/ibm_emac_core.c
index 0de3bb906174..14e9b6315f20 100644
--- a/drivers/net/ibm_emac/ibm_emac_core.c
+++ b/drivers/net/ibm_emac/ibm_emac_core.c
@@ -1875,6 +1875,9 @@ static int emac_init_device(struct ocp_device *ocpdev, struct ibm_ocp_mal *mal)
                 rc = -ENODEV;
                 goto bail;
         }
+        
+        /* Disable any PHY features not supported by the platform */
+        ep->phy_mii.def->features &= ~emacdata->phy_feat_exc;
 
         /* Setup initial PHY config & startup aneg */
         if (ep->phy_mii.def->ops->init)
@@ -1882,6 +1885,34 @@ static int emac_init_device(struct ocp_device *ocpdev, struct ibm_ocp_mal *mal)
         netif_carrier_off(ndev);
         if (ep->phy_mii.def->features & SUPPORTED_Autoneg)
                 ep->want_autoneg = 1;
+        else {
+                ep->want_autoneg = 0;
+                
+                /* Select highest supported speed/duplex */
+                if (ep->phy_mii.def->features & SUPPORTED_1000baseT_Full) {
+                        ep->phy_mii.speed = SPEED_1000;
+                        ep->phy_mii.duplex = DUPLEX_FULL;
+                } else if (ep->phy_mii.def->features & 
+                           SUPPORTED_1000baseT_Half) {
+                        ep->phy_mii.speed = SPEED_1000;
+                        ep->phy_mii.duplex = DUPLEX_HALF;
+                } else if (ep->phy_mii.def->features & 
+                           SUPPORTED_100baseT_Full) {
+                        ep->phy_mii.speed = SPEED_100;
+                        ep->phy_mii.duplex = DUPLEX_FULL;
+                } else if (ep->phy_mii.def->features & 
+                           SUPPORTED_100baseT_Half) {
+                        ep->phy_mii.speed = SPEED_100;
+                        ep->phy_mii.duplex = DUPLEX_HALF;
+                } else if (ep->phy_mii.def->features & 
+                           SUPPORTED_10baseT_Full) {
+                        ep->phy_mii.speed = SPEED_10;
+                        ep->phy_mii.duplex = DUPLEX_FULL;
+                } else {
+                        ep->phy_mii.speed = SPEED_10;
+                        ep->phy_mii.duplex = DUPLEX_HALF;
+                }
+        }
         emac_start_link(ep, NULL);
 
         /* read the MAC Address */
diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index e64df4d0800b..83334db2921c 100644
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -584,7 +584,7 @@ static inline int ns83820_add_rx_skb(struct ns83820 *dev, struct sk_buff *skb)
         return 0;
 }
 
-static inline int rx_refill(struct net_device *ndev, int gfp)
+static inline int rx_refill(struct net_device *ndev, unsigned int __nocast gfp)
 {
         struct ns83820 *dev = PRIV(ndev);
         unsigned i;
diff --git a/drivers/net/pcmcia/smc91c92_cs.c b/drivers/net/pcmcia/smc91c92_cs.c
index d652e1eddb45..c7cca842e5ee 100644
--- a/drivers/net/pcmcia/smc91c92_cs.c
+++ b/drivers/net/pcmcia/smc91c92_cs.c
@@ -1832,7 +1832,7 @@ static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
 {
     struct dev_mc_list  *mc_addr;
 
-    for (mc_addr = addrs;  mc_addr && --count > 0;  mc_addr = mc_addr->next) {
+    for (mc_addr = addrs;  mc_addr && count-- > 0;  mc_addr = mc_addr->next) {
         u_int position = ether_crc(6, mc_addr->dmi_addr);
 #ifndef final_version           /* Verify multicast address. */
         if ((mc_addr->dmi_addr[0] & 1) == 0)
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index fd398da4993b..c2e6484ef138 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -2837,21 +2837,29 @@ static void skge_netpoll(struct net_device *dev)
 static int skge_set_mac_address(struct net_device *dev, void *p)
 {
         struct skge_port *skge = netdev_priv(dev);
-        struct sockaddr *addr = p;
-        int err = 0;
+        struct skge_hw *hw = skge->hw;
+        unsigned port = skge->port;
+        const struct sockaddr *addr = p;
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
-        skge_down(dev);
+        spin_lock_bh(&hw->phy_lock);
         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
-        memcpy_toio(skge->hw->regs + B2_MAC_1 + skge->port*8,
+        memcpy_toio(hw->regs + B2_MAC_1 + port*8,
                     dev->dev_addr, ETH_ALEN);
-        memcpy_toio(skge->hw->regs + B2_MAC_2 + skge->port*8,
+        memcpy_toio(hw->regs + B2_MAC_2 + port*8,
                     dev->dev_addr, ETH_ALEN);
-        if (dev->flags & IFF_UP)
-                err = skge_up(dev);
-        return err;
+
+        if (hw->chip_id == CHIP_ID_GENESIS)
+                xm_outaddr(hw, port, XM_SA, dev->dev_addr);
+        else {
+                gma_set_addr(hw, port, GM_SRC_ADDR_1L, dev->dev_addr);
+                gma_set_addr(hw, port, GM_SRC_ADDR_2L, dev->dev_addr);
+        }
+        spin_unlock_bh(&hw->phy_lock);
+
+        return 0;
 }
 
 static const struct {
diff --git a/drivers/net/starfire.c b/drivers/net/starfire.c
index 88b89dc95c77..efdb179ecc8c 100644
--- a/drivers/net/starfire.c
+++ b/drivers/net/starfire.c
@@ -133,14 +133,18 @@
         - finally added firmware (GPL'ed by Adaptec)
         - removed compatibility code for 2.2.x
 
+        LK1.4.2.1 (Ion Badulescu)
+        - fixed 32/64 bit issues on i386 + CONFIG_HIGHMEM
+        - added 32-bit padding to outgoing skb's, removed previous workaround
+
 TODO:   - fix forced speed/duplexing code (broken a long time ago, when
         somebody converted the driver to use the generic MII code)
         - fix VLAN support
 */
 
 #define DRV_NAME        "starfire"
-#define DRV_VERSION     "1.03+LK1.4.2"
-#define DRV_RELDATE     "January 19, 2005"
+#define DRV_VERSION     "1.03+LK1.4.2.1"
+#define DRV_RELDATE     "October 3, 2005"
 
 #include <linux/config.h>
 #include <linux/version.h>
@@ -165,6 +169,14 @@ TODO:	- fix forced speed/duplexing code (broken a long time ago, when
  * of length 1. If and when this is fixed, the #define below can be removed.
  */
 #define HAS_BROKEN_FIRMWARE
+
+/*
+ * If using the broken firmware, data must be padded to the next 32-bit boundary.
+ */
+#ifdef HAS_BROKEN_FIRMWARE
+#define PADDING_MASK 3
+#endif
+
 /*
  * Define this if using the driver with the zero-copy patch
  */
@@ -257,9 +269,10 @@ static int full_duplex[MAX_UNITS] = {0, };
  * This SUCKS.
  * We need a much better method to determine if dma_addr_t is 64-bit.
  */
-#if (defined(__i386__) && defined(CONFIG_HIGHMEM) && (LINUX_VERSION_CODE > 0x20500 || defined(CONFIG_HIGHMEM64G))) || defined(__x86_64__) || defined (__ia64__) || defined(__mips64__) || (defined(__mips__) && defined(CONFIG_HIGHMEM) && defined(CONFIG_64BIT_PHYS_ADDR))
+#if (defined(__i386__) && defined(CONFIG_HIGHMEM64G)) || defined(__x86_64__) || defined (__ia64__) || defined(__mips64__) || (defined(__mips__) && defined(CONFIG_HIGHMEM) && defined(CONFIG_64BIT_PHYS_ADDR))
 /* 64-bit dma_addr_t */
 #define ADDR_64BITS     /* This chip uses 64 bit addresses. */
+#define netdrv_addr_t u64
 #define cpu_to_dma(x) cpu_to_le64(x)
 #define dma_to_cpu(x) le64_to_cpu(x)
 #define RX_DESC_Q_ADDR_SIZE RxDescQAddr64bit
@@ -268,6 +281,7 @@ static int full_duplex[MAX_UNITS] = {0, };
 #define TX_COMPL_Q_ADDR_SIZE TxComplQAddr64bit
 #define RX_DESC_ADDR_SIZE RxDescAddr64bit
 #else  /* 32-bit dma_addr_t */
+#define netdrv_addr_t u32
 #define cpu_to_dma(x) cpu_to_le32(x)
 #define dma_to_cpu(x) le32_to_cpu(x)
 #define RX_DESC_Q_ADDR_SIZE RxDescQAddr32bit
@@ -1333,21 +1347,10 @@ static int start_tx(struct sk_buff *skb, struct net_device *dev)
         }
 
 #if defined(ZEROCOPY) && defined(HAS_BROKEN_FIRMWARE)
-        {
-                int has_bad_length = 0;
-
-                if (skb_first_frag_len(skb) == 1)
-                        has_bad_length = 1;
-                else {
-                        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
-                                if (skb_shinfo(skb)->frags[i].size == 1) {
-                                        has_bad_length = 1;
-                                        break;
-                                }
-                }
-
-                if (has_bad_length)
-                        skb_checksum_help(skb, 0);
+        if (skb->ip_summed == CHECKSUM_HW) {
+                skb = skb_padto(skb, (skb->len + PADDING_MASK) & ~PADDING_MASK);
+                if (skb == NULL)
+                        return NETDEV_TX_OK;
         }
 #endif /* ZEROCOPY && HAS_BROKEN_FIRMWARE */
 
@@ -2127,13 +2130,12 @@ static int __init starfire_init (void)
 #endif
 #endif
 
-#ifndef ADDR_64BITS
         /* we can do this test only at run-time... sigh */
-        if (sizeof(dma_addr_t) == sizeof(u64)) {
-                printk("This driver has not been ported to this 64-bit architecture yet\n");
+        if (sizeof(dma_addr_t) != sizeof(netdrv_addr_t)) {
+                printk("This driver has dma_addr_t issues, please send email to maintainer\n");
                 return -ENODEV;
         }
-#endif /* not ADDR_64BITS */
+
         return pci_module_init (&starfire_driver);
 }
 
diff --git a/drivers/net/sungem.h b/drivers/net/sungem.h
index ff8ae5f79970..16edbb1a4a7a 100644
--- a/drivers/net/sungem.h
+++ b/drivers/net/sungem.h
@@ -1035,7 +1035,8 @@ struct gem {
                         
 #define ALIGNED_RX_SKB_ADDR(addr) \
         ((((unsigned long)(addr) + (64UL - 1UL)) & ~(64UL - 1UL)) - (unsigned long)(addr))
-static __inline__ struct sk_buff *gem_alloc_skb(int size, int gfp_flags)
+static __inline__ struct sk_buff *gem_alloc_skb(int size,
+                                                unsigned int __nocast gfp_flags)
 {
         struct sk_buff *skb = alloc_skb(size + 64, gfp_flags);
 
diff --git a/drivers/net/tokenring/ibmtr.c b/drivers/net/tokenring/ibmtr.c
index e7b001017b9a..32057e65808b 100644
--- a/drivers/net/tokenring/ibmtr.c
+++ b/drivers/net/tokenring/ibmtr.c
@@ -531,7 +531,6 @@ static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
                         if (!time_after(jiffies, timeout)) continue;
                         DPRINTK( "Hardware timeout during initialization.\n");
                         iounmap(t_mmio);
-                        kfree(ti);
                         return -ENODEV;
                 }
                 ti->sram_phys =
@@ -645,7 +644,6 @@ static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
                         DPRINTK("Unknown shared ram paging info %01X\n",
                                                         ti->shared_ram_paging);
                         iounmap(t_mmio); 
-                        kfree(ti);
                         return -ENODEV;
                         break;
                 } /*end switch shared_ram_paging */
@@ -675,7 +673,6 @@ static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
                         "driver limit (%05x), adapter not started.\n",
                         chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
                         iounmap(t_mmio);
-                        kfree(ti);
                         return -ENODEV;
                 } else { /* seems cool, record what we have figured out */
                         ti->sram_base = new_base >> 12;
@@ -690,7 +687,6 @@ static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
                 DPRINTK("Could not grab irq %d.  Halting Token Ring driver.\n",
                                         irq);
                 iounmap(t_mmio);
-                kfree(ti);
                 return -ENODEV;
         }
         /*?? Now, allocate some of the PIO PORTs for this driver.. */
@@ -699,7 +695,6 @@ static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
                 DPRINTK("Could not grab PIO range. Halting driver.\n");
                 free_irq(dev->irq, dev);
                 iounmap(t_mmio);
-                kfree(ti);
                 return -EBUSY;
         }
 
diff --git a/drivers/net/tulip/21142.c b/drivers/net/tulip/21142.c
index 5db694c4eb02..683f14b01c06 100644
--- a/drivers/net/tulip/21142.c
+++ b/drivers/net/tulip/21142.c
@@ -172,7 +172,7 @@ void t21142_lnk_change(struct net_device *dev, int csr5)
                         int i;
                         for (i = 0; i < tp->mtable->leafcount; i++)
                                 if (tp->mtable->mleaf[i].media == dev->if_port) {
-                                        int startup = ! ((tp->chip_id == DC21143 && tp->revision == 65));
+                                        int startup = ! ((tp->chip_id == DC21143 && (tp->revision == 48 || tp->revision == 65)));
                                         tp->cur_index = i;
                                         tulip_select_media(dev, startup);
                                         setup_done = 1;
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c
index 6deb7cc810cc..cf3daaa1b369 100644
--- a/drivers/net/wireless/orinoco.c
+++ b/drivers/net/wireless/orinoco.c
@@ -503,9 +503,14 @@ static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
                 return 0;
         }
 
-        /* Length of the packet body */
-        /* FIXME: what if the skb is smaller than this? */
-        len = max_t(int,skb->len - ETH_HLEN, ETH_ZLEN - ETH_HLEN);
+        /* Check packet length, pad short packets, round up odd length */
+        len = max_t(int, ALIGN(skb->len, 2), ETH_ZLEN);
+        if (skb->len < len) {
+                skb = skb_padto(skb, len);
+                if (skb == NULL)
+                        goto fail;
+        }
+        len -= ETH_HLEN;
 
         eh = (struct ethhdr *)skb->data;
 
@@ -557,8 +562,7 @@ static int orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
                 p = skb->data;
         }
 
-        /* Round up for odd length packets */
-        err = hermes_bap_pwrite(hw, USER_BAP, p, ALIGN(data_len, 2),
+        err = hermes_bap_pwrite(hw, USER_BAP, p, data_len,
                                 txfid, data_off);
         if (err) {
                 printk(KERN_ERR "%s: Error %d writing packet to BAP\n",
diff --git a/drivers/s390/net/qeth.h b/drivers/s390/net/qeth.h
index 2ad4797ce024..9963479ba89f 100644
--- a/drivers/s390/net/qeth.h
+++ b/drivers/s390/net/qeth.h
@@ -686,6 +686,7 @@ struct qeth_seqno {
         __u32 pdu_hdr;
         __u32 pdu_hdr_ack;
         __u16 ipa;
+        __u32 pkt_seqno;
 };
 
 struct qeth_reply {
@@ -848,6 +849,7 @@ qeth_realloc_headroom(struct qeth_card *card, struct sk_buff **skb, int size)
                                   "on interface %s", QETH_CARD_IFNAME(card));
                         return -ENOMEM;
                 }
+                kfree_skb(*skb);
                 *skb = new_skb;
         }
         return 0;
diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index 71de834ece1a..bd28e2438d7f 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -511,7 +511,7 @@ static int
 __qeth_set_offline(struct ccwgroup_device *cgdev, int recovery_mode)
 {
         struct qeth_card *card = (struct qeth_card *) cgdev->dev.driver_data;
-        int rc = 0;
+        int rc = 0, rc2 = 0, rc3 = 0;
         enum qeth_card_states recover_flag;
 
         QETH_DBF_TEXT(setup, 3, "setoffl");
@@ -523,11 +523,13 @@ __qeth_set_offline(struct ccwgroup_device *cgdev, int recovery_mode)
                            CARD_BUS_ID(card));
                 return -ERESTARTSYS;
         }
-        if ((rc = ccw_device_set_offline(CARD_DDEV(card))) ||
-            (rc = ccw_device_set_offline(CARD_WDEV(card))) ||
-            (rc = ccw_device_set_offline(CARD_RDEV(card)))) {
+        rc  = ccw_device_set_offline(CARD_DDEV(card));
+        rc2 = ccw_device_set_offline(CARD_WDEV(card));
+        rc3 = ccw_device_set_offline(CARD_RDEV(card));
+        if (!rc)
+                rc = (rc2) ? rc2 : rc3;
+        if (rc)
                 QETH_DBF_TEXT_(setup, 2, "1err%d", rc);
-        }
         if (recover_flag == CARD_STATE_UP)
                 card->state = CARD_STATE_RECOVER;
         qeth_notify_processes();
@@ -1046,6 +1048,7 @@ qeth_setup_card(struct qeth_card *card)
         spin_lock_init(&card->vlanlock);
         card->vlangrp = NULL;
 #endif
+        spin_lock_init(&card->lock);
         spin_lock_init(&card->ip_lock);
         spin_lock_init(&card->thread_mask_lock);
         card->thread_start_mask = 0;
@@ -1626,16 +1629,6 @@ qeth_cmd_timeout(unsigned long data)
         spin_unlock_irqrestore(&reply->card->lock, flags);
 }
 
-static void
-qeth_reset_ip_addresses(struct qeth_card *card)
-{
-        QETH_DBF_TEXT(trace, 2, "rstipadd");
-
-        qeth_clear_ip_list(card, 0, 1);
-        /* this function will also schedule the SET_IP_THREAD */
-        qeth_set_multicast_list(card->dev);
-}
-
 static struct qeth_ipa_cmd *
 qeth_check_ipa_data(struct qeth_card *card, struct qeth_cmd_buffer *iob)
 {
@@ -1664,9 +1657,8 @@ qeth_check_ipa_data(struct qeth_card *card, struct qeth_cmd_buffer *iob)
                                            "IP address reset.\n",
                                            QETH_CARD_IFNAME(card),
                                            card->info.chpid);
-                                card->lan_online = 1;
                                 netif_carrier_on(card->dev);
-                                qeth_reset_ip_addresses(card);
+                                qeth_schedule_recovery(card);
                                 return NULL;
                         case IPA_CMD_REGISTER_LOCAL_ADDR:
                                 QETH_DBF_TEXT(trace,3, "irla");
@@ -2387,6 +2379,7 @@ qeth_layer2_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
                 skb_pull(skb, VLAN_HLEN);
         }
 #endif
+        *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
         return vlan_id;
 }
 
@@ -3014,7 +3007,7 @@ qeth_alloc_buffer_pool(struct qeth_card *card)
                         return -ENOMEM;
                 }
                 for(j = 0; j < QETH_MAX_BUFFER_ELEMENTS(card); ++j){
-                        ptr = (void *) __get_free_page(GFP_KERNEL);
+                        ptr = (void *) __get_free_page(GFP_KERNEL|GFP_DMA);
                         if (!ptr) {
                                 while (j > 0)
                                         free_page((unsigned long)
@@ -3058,7 +3051,8 @@ qeth_alloc_qdio_buffers(struct qeth_card *card)
         if (card->qdio.state == QETH_QDIO_ALLOCATED)
                 return 0;
 
-        card->qdio.in_q = kmalloc(sizeof(struct qeth_qdio_q), GFP_KERNEL);
+        card->qdio.in_q = kmalloc(sizeof(struct qeth_qdio_q), 
+                                  GFP_KERNEL|GFP_DMA);
         if (!card->qdio.in_q)
                 return - ENOMEM;
         QETH_DBF_TEXT(setup, 2, "inq");
@@ -3083,7 +3077,7 @@ qeth_alloc_qdio_buffers(struct qeth_card *card)
         }
         for (i = 0; i < card->qdio.no_out_queues; ++i){
                 card->qdio.out_qs[i] = kmalloc(sizeof(struct qeth_qdio_out_q),
-                                               GFP_KERNEL);
+                                               GFP_KERNEL|GFP_DMA);
                 if (!card->qdio.out_qs[i]){
                         while (i > 0)
                                 kfree(card->qdio.out_qs[--i]);
@@ -6470,6 +6464,9 @@ qeth_query_ipassists_cb(struct qeth_card *card, struct qeth_reply *reply,
         if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
                 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
                 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
+                /* Disable IPV6 support hard coded for Hipersockets */
+                if(card->info.type == QETH_CARD_TYPE_IQD)
+                        card->options.ipa4.supported_funcs &= ~IPA_IPV6;
         } else {
 #ifdef CONFIG_QETH_IPV6
                 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 20019b82b4a8..be96cb78e3b5 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -521,6 +521,14 @@ config SCSI_SATA_SIL
 
           If unsure, say N.
 
+config SCSI_SATA_SIL24
+        tristate "Silicon Image 3124/3132 SATA support"
+        depends on SCSI_SATA && PCI && EXPERIMENTAL
+        help
+          This option enables support for Silicon Image 3124/3132 Serial ATA.
+
+          If unsure, say N.
+
 config SCSI_SATA_SIS
         tristate "SiS 964/180 SATA support"
         depends on SCSI_SATA && PCI && EXPERIMENTAL
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 48529d180ca8..e2e3d8671930 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -130,6 +130,7 @@ obj-$(CONFIG_SCSI_ATA_PIIX)	+= libata.o ata_piix.o
 obj-$(CONFIG_SCSI_SATA_PROMISE) += libata.o sata_promise.o
 obj-$(CONFIG_SCSI_SATA_QSTOR)   += libata.o sata_qstor.o
 obj-$(CONFIG_SCSI_SATA_SIL)     += libata.o sata_sil.o
+obj-$(CONFIG_SCSI_SATA_SIL24)   += libata.o sata_sil24.o
 obj-$(CONFIG_SCSI_SATA_VIA)     += libata.o sata_via.o
 obj-$(CONFIG_SCSI_SATA_VITESSE) += libata.o sata_vsc.o
 obj-$(CONFIG_SCSI_SATA_SIS)     += libata.o sata_sis.o
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 6e4bb36f8d7c..f0d8f89b5d40 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -680,17 +680,36 @@ static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *
 
         for (i = 0; i < host_set->n_ports; i++) {
                 struct ata_port *ap;
-                u32 tmp;
 
-                VPRINTK("port %u\n", i);
+                if (!(irq_stat & (1 << i)))
+                        continue;
+
                 ap = host_set->ports[i];
-                tmp = irq_stat & (1 << i);
-                if (tmp && ap) {
+                if (ap) {
                         struct ata_queued_cmd *qc;
                         qc = ata_qc_from_tag(ap, ap->active_tag);
-                        if (ahci_host_intr(ap, qc))
-                                irq_ack |= (1 << i);
+                        if (!ahci_host_intr(ap, qc))
+                                if (ata_ratelimit()) {
+                                        struct pci_dev *pdev =
+                                          to_pci_dev(ap->host_set->dev);
+                                        printk(KERN_WARNING
+                                          "ahci(%s): unhandled interrupt on port %u\n",
+                                          pci_name(pdev), i);
+                                }
+
+                        VPRINTK("port %u\n", i);
+                } else {
+                        VPRINTK("port %u (no irq)\n", i);
+                        if (ata_ratelimit()) {
+                                struct pci_dev *pdev =
+                                  to_pci_dev(ap->host_set->dev);
+                                printk(KERN_WARNING
+                                  "ahci(%s): interrupt on disabled port %u\n",
+                                  pci_name(pdev), i);
+                        }
                 }
+
+                irq_ack |= (1 << i);
         }
 
         if (irq_ack) {
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 943b44c3c16f..9aa93087d495 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -48,6 +48,7 @@
 #include <linux/completion.h>
 #include <linux/suspend.h>
 #include <linux/workqueue.h>
+#include <linux/jiffies.h>
 #include <scsi/scsi.h>
 #include "scsi.h"
 #include "scsi_priv.h"
@@ -62,6 +63,7 @@
 static unsigned int ata_busy_sleep (struct ata_port *ap,
                                     unsigned long tmout_pat,
                                     unsigned long tmout);
+static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev);
 static void ata_set_mode(struct ata_port *ap);
 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
 static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift);
@@ -69,7 +71,6 @@ static int fgb(u32 bitmap);
 static int ata_choose_xfer_mode(struct ata_port *ap,
                                 u8 *xfer_mode_out,
                                 unsigned int *xfer_shift_out);
-static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
 static void __ata_qc_complete(struct ata_queued_cmd *qc);
 
 static unsigned int ata_unique_id = 1;
@@ -1131,7 +1132,7 @@ static inline void ata_dump_id(struct ata_device *dev)
 static void ata_dev_identify(struct ata_port *ap, unsigned int device)
 {
         struct ata_device *dev = &ap->device[device];
-        unsigned int i;
+        unsigned int major_version;
         u16 tmp;
         unsigned long xfer_modes;
         u8 status;
@@ -1229,9 +1230,9 @@ retry:
          * common ATA, ATAPI feature tests
          */
 
-        /* we require LBA and DMA support (bits 8 & 9 of word 49) */
-        if (!ata_id_has_dma(dev->id) || !ata_id_has_lba(dev->id)) {
-                printk(KERN_DEBUG "ata%u: no dma/lba\n", ap->id);
+        /* we require DMA support (bits 8 of word 49) */
+        if (!ata_id_has_dma(dev->id)) {
+                printk(KERN_DEBUG "ata%u: no dma\n", ap->id);
                 goto err_out_nosup;
         }
 
@@ -1251,32 +1252,69 @@ retry:
                 if (!ata_id_is_ata(dev->id))    /* sanity check */
                         goto err_out_nosup;
 
+                /* get major version */
                 tmp = dev->id[ATA_ID_MAJOR_VER];
-                for (i = 14; i >= 1; i--)
-                        if (tmp & (1 << i))
+                for (major_version = 14; major_version >= 1; major_version--)
+                        if (tmp & (1 << major_version))
                                 break;
 
-                /* we require at least ATA-3 */
-                if (i < 3) {
-                        printk(KERN_DEBUG "ata%u: no ATA-3\n", ap->id);
-                        goto err_out_nosup;
-                }
+                /*
+                 * The exact sequence expected by certain pre-ATA4 drives is:
+                 * SRST RESET
+                 * IDENTIFY
+                 * INITIALIZE DEVICE PARAMETERS
+                 * anything else..
+                 * Some drives were very specific about that exact sequence.
+                 */
+                if (major_version < 4 || (!ata_id_has_lba(dev->id)))
+                        ata_dev_init_params(ap, dev);
+
+                if (ata_id_has_lba(dev->id)) {
+                        dev->flags |= ATA_DFLAG_LBA;
+
+                        if (ata_id_has_lba48(dev->id)) {
+                                dev->flags |= ATA_DFLAG_LBA48;
+                                dev->n_sectors = ata_id_u64(dev->id, 100);
+                        } else {
+                                dev->n_sectors = ata_id_u32(dev->id, 60);
+                        }
+
+                        /* print device info to dmesg */
+                        printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors:%s\n",
+                               ap->id, device,
+                               major_version,
+                               ata_mode_string(xfer_modes),
+                               (unsigned long long)dev->n_sectors,
+                               dev->flags & ATA_DFLAG_LBA48 ? " LBA48" : " LBA");
+                } else { 
+                        /* CHS */
+
+                        /* Default translation */
+                        dev->cylinders  = dev->id[1];
+                        dev->heads      = dev->id[3];
+                        dev->sectors    = dev->id[6];
+                        dev->n_sectors  = dev->cylinders * dev->heads * dev->sectors;
+
+                        if (ata_id_current_chs_valid(dev->id)) {
+                                /* Current CHS translation is valid. */
+                                dev->cylinders = dev->id[54];
+                                dev->heads     = dev->id[55];
+                                dev->sectors   = dev->id[56];
+                                
+                                dev->n_sectors = ata_id_u32(dev->id, 57);
+                        }
+
+                        /* print device info to dmesg */
+                        printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors: CHS %d/%d/%d\n",
+                               ap->id, device,
+                               major_version,
+                               ata_mode_string(xfer_modes),
+                               (unsigned long long)dev->n_sectors,
+                               (int)dev->cylinders, (int)dev->heads, (int)dev->sectors);
 
-                if (ata_id_has_lba48(dev->id)) {
-                        dev->flags |= ATA_DFLAG_LBA48;
-                        dev->n_sectors = ata_id_u64(dev->id, 100);
-                } else {
-                        dev->n_sectors = ata_id_u32(dev->id, 60);
                 }
 
                 ap->host->max_cmd_len = 16;
-
-                /* print device info to dmesg */
-                printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors:%s\n",
-                       ap->id, device,
-                       ata_mode_string(xfer_modes),
-                       (unsigned long long)dev->n_sectors,
-                       dev->flags & ATA_DFLAG_LBA48 ? " lba48" : "");
         }
 
         /* ATAPI-specific feature tests */
@@ -2144,6 +2182,54 @@ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
 }
 
 /**
+ *      ata_dev_init_params - Issue INIT DEV PARAMS command
+ *      @ap: Port associated with device @dev
+ *      @dev: Device to which command will be sent
+ *
+ *      LOCKING:
+ */
+
+static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev)
+{
+        DECLARE_COMPLETION(wait);
+        struct ata_queued_cmd *qc;
+        int rc;
+        unsigned long flags;
+        u16 sectors = dev->id[6];
+        u16 heads   = dev->id[3];
+
+        /* Number of sectors per track 1-255. Number of heads 1-16 */
+        if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
+                return;
+
+        /* set up init dev params taskfile */
+        DPRINTK("init dev params \n");
+
+        qc = ata_qc_new_init(ap, dev);
+        BUG_ON(qc == NULL);
+
+        qc->tf.command = ATA_CMD_INIT_DEV_PARAMS;
+        qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        qc->tf.protocol = ATA_PROT_NODATA;
+        qc->tf.nsect = sectors;
+        qc->tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
+
+        qc->waiting = &wait;
+        qc->complete_fn = ata_qc_complete_noop;
+
+        spin_lock_irqsave(&ap->host_set->lock, flags);
+        rc = ata_qc_issue(qc);
+        spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+        if (rc)
+                ata_port_disable(ap);
+        else
+                wait_for_completion(&wait);
+
+        DPRINTK("EXIT\n");
+}
+
+/**
  *      ata_sg_clean - Unmap DMA memory associated with command
  *      @qc: Command containing DMA memory to be released
  *
@@ -2507,20 +2593,20 @@ void ata_poll_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
 static unsigned long ata_pio_poll(struct ata_port *ap)
 {
         u8 status;
-        unsigned int poll_state = PIO_ST_UNKNOWN;
-        unsigned int reg_state = PIO_ST_UNKNOWN;
-        const unsigned int tmout_state = PIO_ST_TMOUT;
-
-        switch (ap->pio_task_state) {
-        case PIO_ST:
-        case PIO_ST_POLL:
-                poll_state = PIO_ST_POLL;
-                reg_state = PIO_ST;
+        unsigned int poll_state = HSM_ST_UNKNOWN;
+        unsigned int reg_state = HSM_ST_UNKNOWN;
+        const unsigned int tmout_state = HSM_ST_TMOUT;
+
+        switch (ap->hsm_task_state) {
+        case HSM_ST:
+        case HSM_ST_POLL:
+                poll_state = HSM_ST_POLL;
+                reg_state = HSM_ST;
                 break;
-        case PIO_ST_LAST:
-        case PIO_ST_LAST_POLL:
-                poll_state = PIO_ST_LAST_POLL;
-                reg_state = PIO_ST_LAST;
+        case HSM_ST_LAST:
+        case HSM_ST_LAST_POLL:
+                poll_state = HSM_ST_LAST_POLL;
+                reg_state = HSM_ST_LAST;
                 break;
         default:
                 BUG();
@@ -2530,14 +2616,14 @@ static unsigned long ata_pio_poll(struct ata_port *ap)
         status = ata_chk_status(ap);
         if (status & ATA_BUSY) {
                 if (time_after(jiffies, ap->pio_task_timeout)) {
-                        ap->pio_task_state = tmout_state;
+                        ap->hsm_task_state = tmout_state;
                         return 0;
                 }
-                ap->pio_task_state = poll_state;
+                ap->hsm_task_state = poll_state;
                 return ATA_SHORT_PAUSE;
         }
 
-        ap->pio_task_state = reg_state;
+        ap->hsm_task_state = reg_state;
         return 0;
 }
 
@@ -2562,14 +2648,14 @@ static int ata_pio_complete (struct ata_port *ap)
          * we enter, BSY will be cleared in a chk-status or two.  If not,
          * the drive is probably seeking or something.  Snooze for a couple
          * msecs, then chk-status again.  If still busy, fall back to
-         * PIO_ST_POLL state.
+         * HSM_ST_POLL state.
          */
         drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
         if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
                 msleep(2);
                 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
                 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
-                        ap->pio_task_state = PIO_ST_LAST_POLL;
+                        ap->hsm_task_state = HSM_ST_LAST_POLL;
                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
                         return 0;
                 }
@@ -2577,14 +2663,14 @@ static int ata_pio_complete (struct ata_port *ap)
 
         drv_stat = ata_wait_idle(ap);
         if (!ata_ok(drv_stat)) {
-                ap->pio_task_state = PIO_ST_ERR;
+                ap->hsm_task_state = HSM_ST_ERR;
                 return 0;
         }
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
         assert(qc != NULL);
 
-        ap->pio_task_state = PIO_ST_IDLE;
+        ap->hsm_task_state = HSM_ST_IDLE;
 
         ata_poll_qc_complete(qc, drv_stat);
 
@@ -2744,7 +2830,7 @@ static void ata_pio_sector(struct ata_queued_cmd *qc)
         unsigned char *buf;
 
         if (qc->cursect == (qc->nsect - 1))
-                ap->pio_task_state = PIO_ST_LAST;
+                ap->hsm_task_state = HSM_ST_LAST;
 
         page = sg[qc->cursg].page;
         offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
@@ -2794,7 +2880,7 @@ static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
         unsigned int offset, count;
 
         if (qc->curbytes + bytes >= qc->nbytes)
-                ap->pio_task_state = PIO_ST_LAST;
+                ap->hsm_task_state = HSM_ST_LAST;
 
 next_sg:
         if (unlikely(qc->cursg >= qc->n_elem)) {
@@ -2816,7 +2902,7 @@ next_sg:
                 for (i = 0; i < words; i++)
                         ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
 
-                ap->pio_task_state = PIO_ST_LAST;
+                ap->hsm_task_state = HSM_ST_LAST;
                 return;
         }
 
@@ -2897,7 +2983,7 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
 err_out:
         printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
               ap->id, dev->devno);
-        ap->pio_task_state = PIO_ST_ERR;
+        ap->hsm_task_state = HSM_ST_ERR;
 }
 
 /**
@@ -2919,14 +3005,14 @@ static void ata_pio_block(struct ata_port *ap)
          * a chk-status or two.  If not, the drive is probably seeking
          * or something.  Snooze for a couple msecs, then
          * chk-status again.  If still busy, fall back to
-         * PIO_ST_POLL state.
+         * HSM_ST_POLL state.
          */
         status = ata_busy_wait(ap, ATA_BUSY, 5);
         if (status & ATA_BUSY) {
                 msleep(2);
                 status = ata_busy_wait(ap, ATA_BUSY, 10);
                 if (status & ATA_BUSY) {
-                        ap->pio_task_state = PIO_ST_POLL;
+                        ap->hsm_task_state = HSM_ST_POLL;
                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
                         return;
                 }
@@ -2938,7 +3024,7 @@ static void ata_pio_block(struct ata_port *ap)
         if (is_atapi_taskfile(&qc->tf)) {
                 /* no more data to transfer or unsupported ATAPI command */
                 if ((status & ATA_DRQ) == 0) {
-                        ap->pio_task_state = PIO_ST_LAST;
+                        ap->hsm_task_state = HSM_ST_LAST;
                         return;
                 }
 
@@ -2946,7 +3032,7 @@ static void ata_pio_block(struct ata_port *ap)
         } else {
                 /* handle BSY=0, DRQ=0 as error */
                 if ((status & ATA_DRQ) == 0) {
-                        ap->pio_task_state = PIO_ST_ERR;
+                        ap->hsm_task_state = HSM_ST_ERR;
                         return;
                 }
 
@@ -2966,7 +3052,7 @@ static void ata_pio_error(struct ata_port *ap)
         printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
                ap->id, drv_stat);
 
-        ap->pio_task_state = PIO_ST_IDLE;
+        ap->hsm_task_state = HSM_ST_IDLE;
 
         ata_poll_qc_complete(qc, drv_stat | ATA_ERR);
 }
@@ -2981,25 +3067,25 @@ fsm_start:
         timeout = 0;
         qc_completed = 0;
 
-        switch (ap->pio_task_state) {
-        case PIO_ST_IDLE:
+        switch (ap->hsm_task_state) {
+        case HSM_ST_IDLE:
                 return;
 
-        case PIO_ST:
+        case HSM_ST:
                 ata_pio_block(ap);
                 break;
 
-        case PIO_ST_LAST:
+        case HSM_ST_LAST:
                 qc_completed = ata_pio_complete(ap);
                 break;
 
-        case PIO_ST_POLL:
-        case PIO_ST_LAST_POLL:
+        case HSM_ST_POLL:
+        case HSM_ST_LAST_POLL:
                 timeout = ata_pio_poll(ap);
                 break;
 
-        case PIO_ST_TMOUT:
-        case PIO_ST_ERR:
+        case HSM_ST_TMOUT:
+        case HSM_ST_ERR:
                 ata_pio_error(ap);
                 return;
         }
@@ -3010,52 +3096,6 @@ fsm_start:
                 goto fsm_start;
 }
 
-static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
-                                struct scsi_cmnd *cmd)
-{
-        DECLARE_COMPLETION(wait);
-        struct ata_queued_cmd *qc;
-        unsigned long flags;
-        int rc;
-
-        DPRINTK("ATAPI request sense\n");
-
-        qc = ata_qc_new_init(ap, dev);
-        BUG_ON(qc == NULL);
-
-        /* FIXME: is this needed? */
-        memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
-
-        ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
-        qc->dma_dir = DMA_FROM_DEVICE;
-
-        memset(&qc->cdb, 0, ap->cdb_len);
-        qc->cdb[0] = REQUEST_SENSE;
-        qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
-
-        qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
-        qc->tf.command = ATA_CMD_PACKET;
-
-        qc->tf.protocol = ATA_PROT_ATAPI;
-        qc->tf.lbam = (8 * 1024) & 0xff;
-        qc->tf.lbah = (8 * 1024) >> 8;
-        qc->nbytes = SCSI_SENSE_BUFFERSIZE;
-
-        qc->waiting = &wait;
-        qc->complete_fn = ata_qc_complete_noop;
-
-        spin_lock_irqsave(&ap->host_set->lock, flags);
-        rc = ata_qc_issue(qc);
-        spin_unlock_irqrestore(&ap->host_set->lock, flags);
-
-        if (rc)
-                ata_port_disable(ap);
-        else
-                wait_for_completion(&wait);
-
-        DPRINTK("EXIT\n");
-}
-
 /**
  *      ata_qc_timeout - Handle timeout of queued command
  *      @qc: Command that timed out
@@ -3173,14 +3213,14 @@ void ata_eng_timeout(struct ata_port *ap)
         DPRINTK("ENTER\n");
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
-        if (!qc) {
+        if (qc)
+                ata_qc_timeout(qc);
+        else {
                 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
                        ap->id);
                 goto out;
         }
 
-        ata_qc_timeout(qc);
-
 out:
         DPRINTK("EXIT\n");
 }
@@ -3238,14 +3278,18 @@ struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
 
                 ata_tf_init(ap, &qc->tf, dev->devno);
 
-                if (dev->flags & ATA_DFLAG_LBA48)
-                        qc->tf.flags |= ATA_TFLAG_LBA48;
+                if (dev->flags & ATA_DFLAG_LBA) {
+                        qc->tf.flags |= ATA_TFLAG_LBA;
+
+                        if (dev->flags & ATA_DFLAG_LBA48)
+                                qc->tf.flags |= ATA_TFLAG_LBA48;
+                }
         }
 
         return qc;
 }
 
-static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
+int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
 {
         return 0;
 }
@@ -3442,7 +3486,7 @@ int ata_qc_issue_prot(struct ata_queued_cmd *qc)
         case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
                 ata_qc_set_polling(qc);
                 ata_tf_to_host_nolock(ap, &qc->tf);
-                ap->pio_task_state = PIO_ST;
+                ap->hsm_task_state = HSM_ST;
                 queue_work(ata_wq, &ap->pio_task);
                 break;
 
@@ -3668,7 +3712,7 @@ u8 ata_bmdma_status(struct ata_port *ap)
                 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
                 host_stat = readb(mmio + ATA_DMA_STATUS);
         } else
-        host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+                host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
         return host_stat;
 }
 
@@ -3888,7 +3932,7 @@ static void atapi_packet_task(void *_data)
                 ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
 
                 /* PIO commands are handled by polling */
-                ap->pio_task_state = PIO_ST;
+                ap->hsm_task_state = HSM_ST;
                 queue_work(ata_wq, &ap->pio_task);
         }
 
@@ -4202,7 +4246,7 @@ int ata_device_add(struct ata_probe_ent *ent)
         for (i = 0; i < count; i++) {
                 struct ata_port *ap = host_set->ports[i];
 
-                scsi_scan_host(ap->host);
+                ata_scsi_scan_host(ap);
         }
 
         dev_set_drvdata(dev, host_set);
@@ -4362,85 +4406,87 @@ void ata_pci_host_stop (struct ata_host_set *host_set)
  *      ata_pci_init_native_mode - Initialize native-mode driver
  *      @pdev:  pci device to be initialized
  *      @port:  array[2] of pointers to port info structures.
+ *      @ports: bitmap of ports present
  *
  *      Utility function which allocates and initializes an
  *      ata_probe_ent structure for a standard dual-port
  *      PIO-based IDE controller.  The returned ata_probe_ent
  *      structure can be passed to ata_device_add().  The returned
  *      ata_probe_ent structure should then be freed with kfree().
+ *
+ *      The caller need only pass the address of the primary port, the
+ *      secondary will be deduced automatically. If the device has non
+ *      standard secondary port mappings this function can be called twice,
+ *      once for each interface.
  */
 
 struct ata_probe_ent *
-ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
+ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int ports)
 {
         struct ata_probe_ent *probe_ent =
                 ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
+        int p = 0;
+
         if (!probe_ent)
                 return NULL;
 
-        probe_ent->n_ports = 2;
         probe_ent->irq = pdev->irq;
         probe_ent->irq_flags = SA_SHIRQ;
 
-        probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
-        probe_ent->port[0].altstatus_addr =
-        probe_ent->port[0].ctl_addr =
-                pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
-        probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
-
-        probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
-        probe_ent->port[1].altstatus_addr =
-        probe_ent->port[1].ctl_addr =
-                pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
-        probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
+        if (ports & ATA_PORT_PRIMARY) {
+                probe_ent->port[p].cmd_addr = pci_resource_start(pdev, 0);
+                probe_ent->port[p].altstatus_addr =
+                probe_ent->port[p].ctl_addr =
+                        pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
+                probe_ent->port[p].bmdma_addr = pci_resource_start(pdev, 4);
+                ata_std_ports(&probe_ent->port[p]);
+                p++;
+        }
 
-        ata_std_ports(&probe_ent->port[0]);
-        ata_std_ports(&probe_ent->port[1]);
+        if (ports & ATA_PORT_SECONDARY) {
+                probe_ent->port[p].cmd_addr = pci_resource_start(pdev, 2);
+                probe_ent->port[p].altstatus_addr =
+                probe_ent->port[p].ctl_addr =
+                        pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
+                probe_ent->port[p].bmdma_addr = pci_resource_start(pdev, 4) + 8;
+                ata_std_ports(&probe_ent->port[p]);
+                p++;
+        }
 
+        probe_ent->n_ports = p;
         return probe_ent;
 }
 
-static struct ata_probe_ent *
-ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port,
-    struct ata_probe_ent **ppe2)
+static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, struct ata_port_info **port, int port_num)
 {
-        struct ata_probe_ent *probe_ent, *probe_ent2;
+        struct ata_probe_ent *probe_ent;
 
         probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
         if (!probe_ent)
                 return NULL;
-        probe_ent2 = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[1]);
-        if (!probe_ent2) {
-                kfree(probe_ent);
-                return NULL;
-        }
 
-        probe_ent->n_ports = 1;
-        probe_ent->irq = 14;
-
-        probe_ent->hard_port_no = 0;
+        
         probe_ent->legacy_mode = 1;
-
-        probe_ent2->n_ports = 1;
-        probe_ent2->irq = 15;
-
-        probe_ent2->hard_port_no = 1;
-        probe_ent2->legacy_mode = 1;
-
-        probe_ent->port[0].cmd_addr = 0x1f0;
-        probe_ent->port[0].altstatus_addr =
-        probe_ent->port[0].ctl_addr = 0x3f6;
-        probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
-
-        probe_ent2->port[0].cmd_addr = 0x170;
-        probe_ent2->port[0].altstatus_addr =
-        probe_ent2->port[0].ctl_addr = 0x376;
-        probe_ent2->port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
-
+        probe_ent->n_ports = 1;
+        probe_ent->hard_port_no = port_num;
+
+        switch(port_num)
+        {
+                case 0:
+                        probe_ent->irq = 14;
+                        probe_ent->port[0].cmd_addr = 0x1f0;
+                        probe_ent->port[0].altstatus_addr =
+                        probe_ent->port[0].ctl_addr = 0x3f6;
+                        break;
+                case 1:
+                        probe_ent->irq = 15;
+                        probe_ent->port[0].cmd_addr = 0x170;
+                        probe_ent->port[0].altstatus_addr =
+                        probe_ent->port[0].ctl_addr = 0x376;
+                        break;
+        }
+        probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4) + 8 * port_num;
         ata_std_ports(&probe_ent->port[0]);
-        ata_std_ports(&probe_ent2->port[0]);
-
-        *ppe2 = probe_ent2;
         return probe_ent;
 }
 
@@ -4469,7 +4515,7 @@ ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port,
 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
                       unsigned int n_ports)
 {
-        struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
+        struct ata_probe_ent *probe_ent = NULL, *probe_ent2 = NULL;
         struct ata_port_info *port[2];
         u8 tmp8, mask;
         unsigned int legacy_mode = 0;
@@ -4486,7 +4532,7 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 
         if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0
             && (pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
-                /* TODO: support transitioning to native mode? */
+                /* TODO: What if one channel is in native mode ... */
                 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
                 mask = (1 << 2) | (1 << 0);
                 if ((tmp8 & mask) != mask)
@@ -4494,11 +4540,20 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
         }
 
         /* FIXME... */
-        if ((!legacy_mode) && (n_ports > 1)) {
-                printk(KERN_ERR "ata: BUG: native mode, n_ports > 1\n");
-                return -EINVAL;
+        if ((!legacy_mode) && (n_ports > 2)) {
+                printk(KERN_ERR "ata: BUG: native mode, n_ports > 2\n");
+                n_ports = 2;
+                /* For now */
         }
 
+        /* FIXME: Really for ATA it isn't safe because the device may be
+           multi-purpose and we want to leave it alone if it was already
+           enabled. Secondly for shared use as Arjan says we want refcounting
+           
+           Checking dev->is_enabled is insufficient as this is not set at
+           boot for the primary video which is BIOS enabled
+         */
+         
         rc = pci_enable_device(pdev);
         if (rc)
                 return rc;
@@ -4509,6 +4564,7 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
                 goto err_out;
         }
 
+        /* FIXME: Should use platform specific mappers for legacy port ranges */
         if (legacy_mode) {
                 if (!request_region(0x1f0, 8, "libata")) {
                         struct resource *conflict, res;
@@ -4553,10 +4609,17 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
                 goto err_out_regions;
 
         if (legacy_mode) {
-                probe_ent = ata_pci_init_legacy_mode(pdev, port, &probe_ent2);
-        } else
-                probe_ent = ata_pci_init_native_mode(pdev, port);
-        if (!probe_ent) {
+                if (legacy_mode & (1 << 0))
+                        probe_ent = ata_pci_init_legacy_port(pdev, port, 0);
+                if (legacy_mode & (1 << 1))
+                        probe_ent2 = ata_pci_init_legacy_port(pdev, port, 1);
+        } else {
+                if (n_ports == 2)
+                        probe_ent = ata_pci_init_native_mode(pdev, port, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
+                else
+                        probe_ent = ata_pci_init_native_mode(pdev, port, ATA_PORT_PRIMARY);
+        }
+        if (!probe_ent && !probe_ent2) {
                 rc = -ENOMEM;
                 goto err_out_regions;
         }
@@ -4668,6 +4731,27 @@ static void __exit ata_exit(void)
 module_init(ata_init);
 module_exit(ata_exit);
 
+static unsigned long ratelimit_time;
+static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
+
+int ata_ratelimit(void)
+{
+        int rc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ata_ratelimit_lock, flags);
+
+        if (time_after(jiffies, ratelimit_time)) {
+                rc = 1;
+                ratelimit_time = jiffies + (HZ/5);
+        } else
+                rc = 0;
+
+        spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
+
+        return rc;
+}
+
 /*
  * libata is essentially a library of internal helper functions for
  * low-level ATA host controller drivers.  As such, the API/ABI is
@@ -4709,6 +4793,7 @@ EXPORT_SYMBOL_GPL(sata_phy_reset);
 EXPORT_SYMBOL_GPL(__sata_phy_reset);
 EXPORT_SYMBOL_GPL(ata_bus_reset);
 EXPORT_SYMBOL_GPL(ata_port_disable);
+EXPORT_SYMBOL_GPL(ata_ratelimit);
 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
 EXPORT_SYMBOL_GPL(ata_scsi_error);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index ee3f1050fb5f..4cf43de4060e 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -49,6 +49,14 @@ static struct ata_device *
 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
 
 
+static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
+                                   void (*done)(struct scsi_cmnd *))
+{
+        ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
+        /* "Invalid field in cbd" */
+        done(cmd);
+}
+
 /**
  *      ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
  *      @sdev: SCSI device for which BIOS geometry is to be determined
@@ -182,7 +190,6 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
 {
         struct scsi_cmnd *cmd = qc->scsicmd;
         u8 err = 0;
-        unsigned char *sb = cmd->sense_buffer;
         /* Based on the 3ware driver translation table */
         static unsigned char sense_table[][4] = {
                 /* BBD|ECC|ID|MAR */
@@ -225,8 +232,6 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
         };
         int i = 0;
 
-        cmd->result = SAM_STAT_CHECK_CONDITION;
-
         /*
          *      Is this an error we can process/parse
          */
@@ -281,11 +286,9 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
                 /* Look for best matches first */
                 if((sense_table[i][0] & err) == sense_table[i][0])
                 {
-                        sb[0] = 0x70;
-                        sb[2] = sense_table[i][1];
-                        sb[7] = 0x0a;
-                        sb[12] = sense_table[i][2];
-                        sb[13] = sense_table[i][3];
+                        ata_scsi_set_sense(cmd, sense_table[i][1] /* sk */,
+                                           sense_table[i][2] /* asc */,
+                                           sense_table[i][3] /* ascq */ );
                         return;
                 }
                 i++;
@@ -300,11 +303,9 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
         {
                 if(stat_table[i][0] & drv_stat)
                 {
-                        sb[0] = 0x70;
-                        sb[2] = stat_table[i][1];
-                        sb[7] = 0x0a;
-                        sb[12] = stat_table[i][2];
-                        sb[13] = stat_table[i][3];
+                        ata_scsi_set_sense(cmd, sense_table[i][1] /* sk */,
+                                           sense_table[i][2] /* asc */,
+                                           sense_table[i][3] /* ascq */ );
                         return;
                 }
                 i++;
@@ -313,15 +314,12 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
         printk(KERN_ERR "ata%u: called with no error (%02X)!\n", qc->ap->id, drv_stat);
         /* additional-sense-code[-qualifier] */
 
-        sb[0] = 0x70;
-        sb[2] = MEDIUM_ERROR;
-        sb[7] = 0x0A;
         if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
-                sb[12] = 0x11; /* "unrecovered read error" */
-                sb[13] = 0x04;
+                ata_scsi_set_sense(cmd, MEDIUM_ERROR, 0x11, 0x4);
+                /* "unrecovered read error" */
         } else {
-                sb[12] = 0x0C; /* "write error -             */
-                sb[13] = 0x02; /*  auto-reallocation failed" */
+                ata_scsi_set_sense(cmd, MEDIUM_ERROR, 0xc, 0x2);
+                /* "write error - auto-reallocation failed" */
         }
 }
 
@@ -440,15 +438,26 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc,
                 ;       /* ignore IMMED bit, violates sat-r05 */
         }
         if (scsicmd[4] & 0x2)
-                return 1;       /* LOEJ bit set not supported */
+                goto invalid_fld;       /* LOEJ bit set not supported */
         if (((scsicmd[4] >> 4) & 0xf) != 0)
-                return 1;       /* power conditions not supported */
+                goto invalid_fld;       /* power conditions not supported */
         if (scsicmd[4] & 0x1) {
                 tf->nsect = 1;  /* 1 sector, lba=0 */
-                tf->lbah = 0x0;
-                tf->lbam = 0x0;
-                tf->lbal = 0x0;
-                tf->device |= ATA_LBA;
+
+                if (qc->dev->flags & ATA_DFLAG_LBA) {
+                        qc->tf.flags |= ATA_TFLAG_LBA;
+
+                        tf->lbah = 0x0;
+                        tf->lbam = 0x0;
+                        tf->lbal = 0x0;
+                        tf->device |= ATA_LBA;
+                } else {
+                        /* CHS */
+                        tf->lbal = 0x1; /* sect */
+                        tf->lbam = 0x0; /* cyl low */
+                        tf->lbah = 0x0; /* cyl high */
+                }
+
                 tf->command = ATA_CMD_VERIFY;   /* READ VERIFY */
         } else {
                 tf->nsect = 0;  /* time period value (0 implies now) */
@@ -463,6 +472,11 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc,
          */
 
         return 0;
+
+invalid_fld:
+        ata_scsi_set_sense(qc->scsicmd, ILLEGAL_REQUEST, 0x24, 0x0);
+        /* "Invalid field in cbd" */
+        return 1;
 }
 
 
@@ -498,6 +512,99 @@ static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 }
 
 /**
+ *      scsi_6_lba_len - Get LBA and transfer length
+ *      @scsicmd: SCSI command to translate
+ *
+ *      Calculate LBA and transfer length for 6-byte commands.
+ *
+ *      RETURNS:
+ *      @plba: the LBA
+ *      @plen: the transfer length
+ */
+
+static void scsi_6_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+{
+        u64 lba = 0;
+        u32 len = 0;
+
+        VPRINTK("six-byte command\n");
+
+        lba |= ((u64)scsicmd[2]) << 8;
+        lba |= ((u64)scsicmd[3]);
+
+        len |= ((u32)scsicmd[4]);
+
+        *plba = lba;
+        *plen = len;
+}
+
+/**
+ *      scsi_10_lba_len - Get LBA and transfer length
+ *      @scsicmd: SCSI command to translate
+ *
+ *      Calculate LBA and transfer length for 10-byte commands.
+ *
+ *      RETURNS:
+ *      @plba: the LBA
+ *      @plen: the transfer length
+ */
+
+static void scsi_10_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+{
+        u64 lba = 0;
+        u32 len = 0;
+
+        VPRINTK("ten-byte command\n");
+
+        lba |= ((u64)scsicmd[2]) << 24;
+        lba |= ((u64)scsicmd[3]) << 16;
+        lba |= ((u64)scsicmd[4]) << 8;
+        lba |= ((u64)scsicmd[5]);
+
+        len |= ((u32)scsicmd[7]) << 8;
+        len |= ((u32)scsicmd[8]);
+
+        *plba = lba;
+        *plen = len;
+}
+
+/**
+ *      scsi_16_lba_len - Get LBA and transfer length
+ *      @scsicmd: SCSI command to translate
+ *
+ *      Calculate LBA and transfer length for 16-byte commands.
+ *
+ *      RETURNS:
+ *      @plba: the LBA
+ *      @plen: the transfer length
+ */
+
+static void scsi_16_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+{
+        u64 lba = 0;
+        u32 len = 0;
+
+        VPRINTK("sixteen-byte command\n");
+
+        lba |= ((u64)scsicmd[2]) << 56;
+        lba |= ((u64)scsicmd[3]) << 48;
+        lba |= ((u64)scsicmd[4]) << 40;
+        lba |= ((u64)scsicmd[5]) << 32;
+        lba |= ((u64)scsicmd[6]) << 24;
+        lba |= ((u64)scsicmd[7]) << 16;
+        lba |= ((u64)scsicmd[8]) << 8;
+        lba |= ((u64)scsicmd[9]);
+
+        len |= ((u32)scsicmd[10]) << 24;
+        len |= ((u32)scsicmd[11]) << 16;
+        len |= ((u32)scsicmd[12]) << 8;
+        len |= ((u32)scsicmd[13]);
+
+        *plba = lba;
+        *plen = len;
+}
+
+/**
  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
  *      @qc: Storage for translated ATA taskfile
  *      @scsicmd: SCSI command to translate
@@ -514,79 +621,102 @@ static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 {
         struct ata_taskfile *tf = &qc->tf;
+        struct ata_device *dev = qc->dev;
+        unsigned int lba   = tf->flags & ATA_TFLAG_LBA;
         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
         u64 dev_sectors = qc->dev->n_sectors;
-        u64 sect = 0;
-        u32 n_sect = 0;
+        u64 block;
+        u32 n_block;
 
         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
         tf->protocol = ATA_PROT_NODATA;
-        tf->device |= ATA_LBA;
-
-        if (scsicmd[0] == VERIFY) {
-                sect |= ((u64)scsicmd[2]) << 24;
-                sect |= ((u64)scsicmd[3]) << 16;
-                sect |= ((u64)scsicmd[4]) << 8;
-                sect |= ((u64)scsicmd[5]);
-
-                n_sect |= ((u32)scsicmd[7]) << 8;
-                n_sect |= ((u32)scsicmd[8]);
-        }
-
-        else if (scsicmd[0] == VERIFY_16) {
-                sect |= ((u64)scsicmd[2]) << 56;
-                sect |= ((u64)scsicmd[3]) << 48;
-                sect |= ((u64)scsicmd[4]) << 40;
-                sect |= ((u64)scsicmd[5]) << 32;
-                sect |= ((u64)scsicmd[6]) << 24;
-                sect |= ((u64)scsicmd[7]) << 16;
-                sect |= ((u64)scsicmd[8]) << 8;
-                sect |= ((u64)scsicmd[9]);
-
-                n_sect |= ((u32)scsicmd[10]) << 24;
-                n_sect |= ((u32)scsicmd[11]) << 16;
-                n_sect |= ((u32)scsicmd[12]) << 8;
-                n_sect |= ((u32)scsicmd[13]);
-        }
 
+        if (scsicmd[0] == VERIFY)
+                scsi_10_lba_len(scsicmd, &block, &n_block);
+        else if (scsicmd[0] == VERIFY_16)
+                scsi_16_lba_len(scsicmd, &block, &n_block);
         else
-                return 1;
-
-        if (!n_sect)
-                return 1;
-        if (sect >= dev_sectors)
-                return 1;
-        if ((sect + n_sect) > dev_sectors)
-                return 1;
+                goto invalid_fld;
+
+        if (!n_block)
+                goto nothing_to_do;
+        if (block >= dev_sectors)
+                goto out_of_range;
+        if ((block + n_block) > dev_sectors)
+                goto out_of_range;
         if (lba48) {
-                if (n_sect > (64 * 1024))
-                        return 1;
+                if (n_block > (64 * 1024))
+                        goto invalid_fld;
         } else {
-                if (n_sect > 256)
-                        return 1;
+                if (n_block > 256)
+                        goto invalid_fld;
         }
 
-        if (lba48) {
-                tf->command = ATA_CMD_VERIFY_EXT;
+        if (lba) {
+                if (lba48) {
+                        tf->command = ATA_CMD_VERIFY_EXT;
+
+                        tf->hob_nsect = (n_block >> 8) & 0xff;
+
+                        tf->hob_lbah = (block >> 40) & 0xff;
+                        tf->hob_lbam = (block >> 32) & 0xff;
+                        tf->hob_lbal = (block >> 24) & 0xff;
+                } else {
+                        tf->command = ATA_CMD_VERIFY;
+
+                        tf->device |= (block >> 24) & 0xf;
+                }
 
-                tf->hob_nsect = (n_sect >> 8) & 0xff;
+                tf->nsect = n_block & 0xff;
 
-                tf->hob_lbah = (sect >> 40) & 0xff;
-                tf->hob_lbam = (sect >> 32) & 0xff;
-                tf->hob_lbal = (sect >> 24) & 0xff;
+                tf->lbah = (block >> 16) & 0xff;
+                tf->lbam = (block >> 8) & 0xff;
+                tf->lbal = block & 0xff;
+
+                tf->device |= ATA_LBA;
         } else {
+                /* CHS */
+                u32 sect, head, cyl, track;
+
+                /* Convert LBA to CHS */
+                track = (u32)block / dev->sectors;
+                cyl   = track / dev->heads;
+                head  = track % dev->heads;
+                sect  = (u32)block % dev->sectors + 1;
+
+                DPRINTK("block %u track %u cyl %u head %u sect %u\n",
+                        (u32)block, track, cyl, head, sect);
+                
+                /* Check whether the converted CHS can fit. 
+                   Cylinder: 0-65535 
+                   Head: 0-15
+                   Sector: 1-255*/
+                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 
+                        goto out_of_range;
+                
                 tf->command = ATA_CMD_VERIFY;
-
-                tf->device |= (sect >> 24) & 0xf;
+                tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
+                tf->lbal = sect;
+                tf->lbam = cyl;
+                tf->lbah = cyl >> 8;
+                tf->device |= head;
         }
 
-        tf->nsect = n_sect & 0xff;
+        return 0;
 
-        tf->lbah = (sect >> 16) & 0xff;
-        tf->lbam = (sect >> 8) & 0xff;
-        tf->lbal = sect & 0xff;
+invalid_fld:
+        ata_scsi_set_sense(qc->scsicmd, ILLEGAL_REQUEST, 0x24, 0x0);
+        /* "Invalid field in cbd" */
+        return 1;
 
-        return 0;
+out_of_range:
+        ata_scsi_set_sense(qc->scsicmd, ILLEGAL_REQUEST, 0x21, 0x0);
+        /* "Logical Block Address out of range" */
+        return 1;
+
+nothing_to_do:
+        qc->scsicmd->result = SAM_STAT_GOOD;
+        return 1;
 }
 
 /**
@@ -612,11 +742,14 @@ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 {
         struct ata_taskfile *tf = &qc->tf;
+        struct ata_device *dev = qc->dev;
+        unsigned int lba   = tf->flags & ATA_TFLAG_LBA;
         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
+        u64 block;
+        u32 n_block;
 
         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
         tf->protocol = qc->dev->xfer_protocol;
-        tf->device |= ATA_LBA;
 
         if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
             scsicmd[0] == READ_16) {
@@ -626,89 +759,115 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
                 tf->flags |= ATA_TFLAG_WRITE;
         }
 
-        if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
-                if (lba48) {
-                        tf->hob_nsect = scsicmd[7];
-                        tf->hob_lbal = scsicmd[2];
-
-                        qc->nsect = ((unsigned int)scsicmd[7] << 8) |
-                                        scsicmd[8];
-                } else {
-                        /* if we don't support LBA48 addressing, the request
-                         * -may- be too large. */
-                        if ((scsicmd[2] & 0xf0) || scsicmd[7])
-                                return 1;
-
-                        /* stores LBA27:24 in lower 4 bits of device reg */
-                        tf->device |= scsicmd[2];
+        /* Calculate the SCSI LBA and transfer length. */
+        switch (scsicmd[0]) {
+        case READ_10:
+        case WRITE_10:
+                scsi_10_lba_len(scsicmd, &block, &n_block);
+                break;
+        case READ_6:
+        case WRITE_6:
+                scsi_6_lba_len(scsicmd, &block, &n_block);
 
-                        qc->nsect = scsicmd[8];
-                }
+                /* for 6-byte r/w commands, transfer length 0
+                 * means 256 blocks of data, not 0 block.
+                 */
+                if (!n_block)
+                        n_block = 256;
+                break;
+        case READ_16:
+        case WRITE_16:
+                scsi_16_lba_len(scsicmd, &block, &n_block);
+                break;
+        default:
+                DPRINTK("no-byte command\n");
+                goto invalid_fld;
+        }
 
-                tf->nsect = scsicmd[8];
-                tf->lbal = scsicmd[5];
-                tf->lbam = scsicmd[4];
-                tf->lbah = scsicmd[3];
+        /* Check and compose ATA command */
+        if (!n_block)
+                /* For 10-byte and 16-byte SCSI R/W commands, transfer
+                 * length 0 means transfer 0 block of data.
+                 * However, for ATA R/W commands, sector count 0 means
+                 * 256 or 65536 sectors, not 0 sectors as in SCSI.
+                 */
+                goto nothing_to_do;
 
-                VPRINTK("ten-byte command\n");
-                if (qc->nsect == 0) /* we don't support length==0 cmds */
-                        return 1;
-                return 0;
-        }
+        if (lba) {
+                if (lba48) {
+                        /* The request -may- be too large for LBA48. */
+                        if ((block >> 48) || (n_block > 65536))
+                                goto out_of_range;
 
-        if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
-                qc->nsect = tf->nsect = scsicmd[4];
-                if (!qc->nsect) {
-                        qc->nsect = 256;
-                        if (lba48)
-                                tf->hob_nsect = 1;
-                }
+                        tf->hob_nsect = (n_block >> 8) & 0xff;
 
-                tf->lbal = scsicmd[3];
-                tf->lbam = scsicmd[2];
-                tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
+                        tf->hob_lbah = (block >> 40) & 0xff;
+                        tf->hob_lbam = (block >> 32) & 0xff;
+                        tf->hob_lbal = (block >> 24) & 0xff;
+                } else { 
+                        /* LBA28 */
 
-                VPRINTK("six-byte command\n");
-                return 0;
-        }
+                        /* The request -may- be too large for LBA28. */
+                        if ((block >> 28) || (n_block > 256))
+                                goto out_of_range;
 
-        if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
-                /* rule out impossible LBAs and sector counts */
-                if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
-                        return 1;
+                        tf->device |= (block >> 24) & 0xf;
+                }
 
-                if (lba48) {
-                        tf->hob_nsect = scsicmd[12];
-                        tf->hob_lbal = scsicmd[6];
-                        tf->hob_lbam = scsicmd[5];
-                        tf->hob_lbah = scsicmd[4];
+                qc->nsect = n_block;
+                tf->nsect = n_block & 0xff;
 
-                        qc->nsect = ((unsigned int)scsicmd[12] << 8) |
-                                        scsicmd[13];
-                } else {
-                        /* once again, filter out impossible non-zero values */
-                        if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
-                            (scsicmd[6] & 0xf0))
-                                return 1;
+                tf->lbah = (block >> 16) & 0xff;
+                tf->lbam = (block >> 8) & 0xff;
+                tf->lbal = block & 0xff;
 
-                        /* stores LBA27:24 in lower 4 bits of device reg */
-                        tf->device |= scsicmd[6];
+                tf->device |= ATA_LBA;
+        } else { 
+                /* CHS */
+                u32 sect, head, cyl, track;
+
+                /* The request -may- be too large for CHS addressing. */
+                if ((block >> 28) || (n_block > 256))
+                        goto out_of_range;
+
+                /* Convert LBA to CHS */
+                track = (u32)block / dev->sectors;
+                cyl   = track / dev->heads;
+                head  = track % dev->heads;
+                sect  = (u32)block % dev->sectors + 1;
+
+                DPRINTK("block %u track %u cyl %u head %u sect %u\n",
+                        (u32)block, track, cyl, head, sect);
+
+                /* Check whether the converted CHS can fit. 
+                   Cylinder: 0-65535 
+                   Head: 0-15
+                   Sector: 1-255*/
+                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
+                        goto out_of_range;
+
+                qc->nsect = n_block;
+                tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
+                tf->lbal = sect;
+                tf->lbam = cyl;
+                tf->lbah = cyl >> 8;
+                tf->device |= head;
+        }
 
-                        qc->nsect = scsicmd[13];
-                }
+        return 0;
 
-                tf->nsect = scsicmd[13];
-                tf->lbal = scsicmd[9];
-                tf->lbam = scsicmd[8];
-                tf->lbah = scsicmd[7];
+invalid_fld:
+        ata_scsi_set_sense(qc->scsicmd, ILLEGAL_REQUEST, 0x24, 0x0);
+        /* "Invalid field in cbd" */
+        return 1;
 
-                VPRINTK("sixteen-byte command\n");
-                if (qc->nsect == 0) /* we don't support length==0 cmds */
-                        return 1;
-                return 0;
-        }
+out_of_range:
+        ata_scsi_set_sense(qc->scsicmd, ILLEGAL_REQUEST, 0x21, 0x0);
+        /* "Logical Block Address out of range" */
+        return 1;
 
-        DPRINTK("no-byte command\n");
+nothing_to_do:
+        qc->scsicmd->result = SAM_STAT_GOOD;
         return 1;
 }
 
@@ -741,6 +900,12 @@ static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
  *      This function sets up an ata_queued_cmd structure for the
  *      SCSI command, and sends that ata_queued_cmd to the hardware.
  *
+ *      The xlat_func argument (actor) returns 0 if ready to execute
+ *      ATA command, else 1 to finish translation. If 1 is returned
+ *      then cmd->result (and possibly cmd->sense_buffer) are assumed
+ *      to be set reflecting an error condition or clean (early)
+ *      termination.
+ *
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
  */
@@ -757,7 +922,7 @@ static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
 
         qc = ata_scsi_qc_new(ap, dev, cmd, done);
         if (!qc)
-                return;
+                goto err_mem;
 
         /* data is present; dma-map it */
         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
@@ -765,7 +930,7 @@ static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
                 if (unlikely(cmd->request_bufflen < 1)) {
                         printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
                                ap->id, dev->devno);
-                        goto err_out;
+                        goto err_did;
                 }
 
                 if (cmd->use_sg)
@@ -780,19 +945,28 @@ static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
         qc->complete_fn = ata_scsi_qc_complete;
 
         if (xlat_func(qc, scsicmd))
-                goto err_out;
+                goto early_finish;
 
         /* select device, send command to hardware */
         if (ata_qc_issue(qc))
-                goto err_out;
+                goto err_did;
 
         VPRINTK("EXIT\n");
         return;
 
-err_out:
+early_finish:
+        ata_qc_free(qc);
+        done(cmd);
+        DPRINTK("EXIT - early finish (good or error)\n");
+        return;
+
+err_did:
         ata_qc_free(qc);
-        ata_bad_cdb(cmd, done);
-        DPRINTK("EXIT - badcmd\n");
+err_mem:
+        cmd->result = (DID_ERROR << 16);
+        done(cmd);
+        DPRINTK("EXIT - internal\n");
+        return;
 }
 
 /**
@@ -859,7 +1033,8 @@ static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
  *      Mapping the response buffer, calling the command's handler,
  *      and handling the handler's return value.  This return value
  *      indicates whether the handler wishes the SCSI command to be
- *      completed successfully, or not.
+ *      completed successfully (0), or not (in which case cmd->result
+ *      and sense buffer are assumed to be set).
  *
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
@@ -878,12 +1053,9 @@ void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
         rc = actor(args, rbuf, buflen);
         ata_scsi_rbuf_put(cmd, rbuf);
 
-        if (rc)
-                ata_bad_cdb(cmd, args->done);
-        else {
+        if (rc == 0)
                 cmd->result = SAM_STAT_GOOD;
-                args->done(cmd);
-        }
+        args->done(cmd);
 }
 
 /**
@@ -1189,8 +1361,16 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
          * in the same manner)
          */
         page_control = scsicmd[2] >> 6;
-        if ((page_control != 0) && (page_control != 3))
-                return 1;
+        switch (page_control) {
+        case 0: /* current */
+                break;  /* supported */
+        case 3: /* saved */
+                goto saving_not_supp;
+        case 1: /* changeable */
+        case 2: /* defaults */
+        default:
+                goto invalid_fld;
+        }
 
         if (six_byte)
                 output_len = 4;
@@ -1221,7 +1401,7 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
                 break;
 
         default:                /* invalid page code */
-                return 1;
+                goto invalid_fld;
         }
 
         if (six_byte) {
@@ -1234,6 +1414,16 @@ unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
         }
 
         return 0;
+
+invalid_fld:
+        ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
+        /* "Invalid field in cbd" */
+        return 1;
+
+saving_not_supp:
+        ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
+         /* "Saving parameters not supported" */
+        return 1;
 }
 
 /**
@@ -1256,10 +1446,20 @@ unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
 
         VPRINTK("ENTER\n");
 
-        if (ata_id_has_lba48(args->id))
-                n_sectors = ata_id_u64(args->id, 100);
-        else
-                n_sectors = ata_id_u32(args->id, 60);
+        if (ata_id_has_lba(args->id)) {
+                if (ata_id_has_lba48(args->id))
+                        n_sectors = ata_id_u64(args->id, 100);
+                else
+                        n_sectors = ata_id_u32(args->id, 60);
+        } else {
+                /* CHS default translation */
+                n_sectors = args->id[1] * args->id[3] * args->id[6];
+
+                if (ata_id_current_chs_valid(args->id))
+                        /* CHS current translation */
+                        n_sectors = ata_id_u32(args->id, 57);
+        }
+
         n_sectors--;            /* ATA TotalUserSectors - 1 */
 
         if (args->cmd->cmnd[0] == READ_CAPACITY) {
@@ -1323,6 +1523,34 @@ unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
 }
 
 /**
+ *      ata_scsi_set_sense - Set SCSI sense data and status
+ *      @cmd: SCSI request to be handled
+ *      @sk: SCSI-defined sense key
+ *      @asc: SCSI-defined additional sense code
+ *      @ascq: SCSI-defined additional sense code qualifier
+ *
+ *      Helper function that builds a valid fixed format, current
+ *      response code and the given sense key (sk), additional sense
+ *      code (asc) and additional sense code qualifier (ascq) with
+ *      a SCSI command status of %SAM_STAT_CHECK_CONDITION and
+ *      DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
+ *
+ *      LOCKING:
+ *      Not required
+ */
+
+void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
+{
+        cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
+
+        cmd->sense_buffer[0] = 0x70;    /* fixed format, current */
+        cmd->sense_buffer[2] = sk;
+        cmd->sense_buffer[7] = 18 - 8;  /* additional sense length */
+        cmd->sense_buffer[12] = asc;
+        cmd->sense_buffer[13] = ascq;
+}
+
+/**
  *      ata_scsi_badcmd - End a SCSI request with an error
  *      @cmd: SCSI request to be handled
  *      @done: SCSI command completion function
@@ -1340,30 +1568,84 @@ unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
 {
         DPRINTK("ENTER\n");
-        cmd->result = SAM_STAT_CHECK_CONDITION;
-
-        cmd->sense_buffer[0] = 0x70;
-        cmd->sense_buffer[2] = ILLEGAL_REQUEST;
-        cmd->sense_buffer[7] = 14 - 8;  /* addnl. sense len. FIXME: correct? */
-        cmd->sense_buffer[12] = asc;
-        cmd->sense_buffer[13] = ascq;
+        ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
 
         done(cmd);
 }
 
+void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
+                         struct scsi_cmnd *cmd)
+{
+        DECLARE_COMPLETION(wait);
+        struct ata_queued_cmd *qc;
+        unsigned long flags;
+        int rc;
+
+        DPRINTK("ATAPI request sense\n");
+
+        qc = ata_qc_new_init(ap, dev);
+        BUG_ON(qc == NULL);
+
+        /* FIXME: is this needed? */
+        memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
+
+        ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
+        qc->dma_dir = DMA_FROM_DEVICE;
+
+        memset(&qc->cdb, 0, ap->cdb_len);
+        qc->cdb[0] = REQUEST_SENSE;
+        qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
+
+        qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        qc->tf.command = ATA_CMD_PACKET;
+
+        qc->tf.protocol = ATA_PROT_ATAPI;
+        qc->tf.lbam = (8 * 1024) & 0xff;
+        qc->tf.lbah = (8 * 1024) >> 8;
+        qc->nbytes = SCSI_SENSE_BUFFERSIZE;
+
+        qc->waiting = &wait;
+        qc->complete_fn = ata_qc_complete_noop;
+
+        spin_lock_irqsave(&ap->host_set->lock, flags);
+        rc = ata_qc_issue(qc);
+        spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+        if (rc)
+                ata_port_disable(ap);
+        else
+                wait_for_completion(&wait);
+
+        DPRINTK("EXIT\n");
+}
+
 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
 {
         struct scsi_cmnd *cmd = qc->scsicmd;
 
-        if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
+        VPRINTK("ENTER, drv_stat == 0x%x\n", drv_stat);
+
+        if (unlikely(drv_stat & (ATA_BUSY | ATA_DRQ)))
+                ata_to_sense_error(qc, drv_stat);
+
+        else if (unlikely(drv_stat & ATA_ERR)) {
                 DPRINTK("request check condition\n");
 
+                /* FIXME: command completion with check condition
+                 * but no sense causes the error handler to run,
+                 * which then issues REQUEST SENSE, fills in the sense 
+                 * buffer, and completes the command (for the second
+                 * time).  We need to issue REQUEST SENSE some other
+                 * way, to avoid completing the command twice.
+                 */
                 cmd->result = SAM_STAT_CHECK_CONDITION;
 
                 qc->scsidone(cmd);
 
                 return 1;
-        } else {
+        }
+
+        else {
                 u8 *scsicmd = cmd->cmnd;
 
                 if (scsicmd[0] == INQUIRY) {
@@ -1371,15 +1653,30 @@ static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
                         unsigned int buflen;
 
                         buflen = ata_scsi_rbuf_get(cmd, &buf);
-                        buf[2] = 0x5;
-                        buf[3] = (buf[3] & 0xf0) | 2;
+
+        /* ATAPI devices typically report zero for their SCSI version,
+         * and sometimes deviate from the spec WRT response data
+         * format.  If SCSI version is reported as zero like normal,
+         * then we make the following fixups:  1) Fake MMC-5 version,
+         * to indicate to the Linux scsi midlayer this is a modern
+         * device.  2) Ensure response data format / ATAPI information
+         * are always correct.
+         */
+        /* FIXME: do we ever override EVPD pages and the like, with
+         * this code?
+         */
+                        if (buf[2] == 0) {
+                                buf[2] = 0x5;
+                                buf[3] = 0x32;
+                        }
+
                         ata_scsi_rbuf_put(cmd, buf);
                 }
+
                 cmd->result = SAM_STAT_GOOD;
         }
 
         qc->scsidone(cmd);
-
         return 0;
 }
 /**
@@ -1640,7 +1937,7 @@ void ata_scsi_simulate(u16 *id,
 
                 case INQUIRY:
                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
-                                ata_bad_cdb(cmd, done);
+                                ata_scsi_invalid_field(cmd, done);
                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
                         else if (scsicmd[2] == 0x00)
@@ -1650,7 +1947,7 @@ void ata_scsi_simulate(u16 *id,
                         else if (scsicmd[2] == 0x83)
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
                         else
-                                ata_bad_cdb(cmd, done);
+                                ata_scsi_invalid_field(cmd, done);
                         break;
 
                 case MODE_SENSE:
@@ -1660,7 +1957,7 @@ void ata_scsi_simulate(u16 *id,
 
                 case MODE_SELECT:       /* unconditionally return */
                 case MODE_SELECT_10:    /* bad-field-in-cdb */
-                        ata_bad_cdb(cmd, done);
+                        ata_scsi_invalid_field(cmd, done);
                         break;
 
                 case READ_CAPACITY:
@@ -1671,7 +1968,7 @@ void ata_scsi_simulate(u16 *id,
                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
                         else
-                                ata_bad_cdb(cmd, done);
+                                ata_scsi_invalid_field(cmd, done);
                         break;
 
                 case REPORT_LUNS:
@@ -1683,8 +1980,26 @@ void ata_scsi_simulate(u16 *id,
 
                 /* all other commands */
                 default:
-                        ata_bad_scsiop(cmd, done);
+                        ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
+                        /* "Invalid command operation code" */
+                        done(cmd);
                         break;
         }
 }
 
+void ata_scsi_scan_host(struct ata_port *ap)
+{
+        struct ata_device *dev;
+        unsigned int i;
+
+        if (ap->flags & ATA_FLAG_PORT_DISABLED)
+                return;
+
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                dev = &ap->device[i];
+
+                if (ata_dev_present(dev))
+                        scsi_scan_target(&ap->host->shost_gendev, 0, i, 0, 0);
+        }
+}
+
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index d608b3a0f6fe..a18f2ac1d4a1 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -39,6 +39,7 @@ struct ata_scsi_args {
 
 /* libata-core.c */
 extern int atapi_enabled;
+extern int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
                                       struct ata_device *dev);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
@@ -51,6 +52,9 @@ extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
 
 
 /* libata-scsi.c */
+extern void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
+                         struct scsi_cmnd *cmd);
+extern void ata_scsi_scan_host(struct ata_port *ap);
 extern void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat);
 extern int ata_scsi_error(struct Scsi_Host *host);
 extern unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
@@ -76,18 +80,10 @@ extern unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
 extern void ata_scsi_badcmd(struct scsi_cmnd *cmd,
                             void (*done)(struct scsi_cmnd *),
                             u8 asc, u8 ascq);
+extern void ata_scsi_set_sense(struct scsi_cmnd *cmd,
+                               u8 sk, u8 asc, u8 ascq);
 extern void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
                         unsigned int (*actor) (struct ata_scsi_args *args,
                                            u8 *rbuf, unsigned int buflen));
 
-static inline void ata_bad_scsiop(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
-{
-        ata_scsi_badcmd(cmd, done, 0x20, 0x00);
-}
-
-static inline void ata_bad_cdb(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
-{
-        ata_scsi_badcmd(cmd, done, 0x24, 0x00);
-}
-
 #endif /* __LIBATA_H__ */
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index 1b3148e842af..c3f637395734 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -34,6 +34,7 @@
 #include <linux/delay.h>
 #include <linux/uio.h>
 #include <asm/uaccess.h>
+#include <linux/fs.h>
 #include <linux/compat.h>
 
 #include <scsi/scsi.h>
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index ea76fe44585e..d457f5673476 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -35,7 +35,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME        "sata_mv"
-#define DRV_VERSION     "0.12"
+#define DRV_VERSION     "0.24"
 
 enum {
         /* BAR's are enumerated in terms of pci_resource_start() terms */
@@ -55,31 +55,61 @@ enum {
         MV_SATAHC_ARBTR_REG_SZ  = MV_MINOR_REG_AREA_SZ,         /* arbiter */
         MV_PORT_REG_SZ          = MV_MINOR_REG_AREA_SZ,
 
-        MV_Q_CT                 = 32,
-        MV_CRQB_SZ              = 32,
-        MV_CRPB_SZ              = 8,
+        MV_USE_Q_DEPTH          = ATA_DEF_QUEUE,
 
-        MV_DMA_BOUNDARY         = 0xffffffffU,
-        SATAHC_MASK             = (~(MV_SATAHC_REG_SZ - 1)),
+        MV_MAX_Q_DEPTH          = 32,
+        MV_MAX_Q_DEPTH_MASK     = MV_MAX_Q_DEPTH - 1,
+
+        /* CRQB needs alignment on a 1KB boundary. Size == 1KB
+         * CRPB needs alignment on a 256B boundary. Size == 256B
+         * SG count of 176 leads to MV_PORT_PRIV_DMA_SZ == 4KB
+         * ePRD (SG) entries need alignment on a 16B boundary. Size == 16B
+         */
+        MV_CRQB_Q_SZ            = (32 * MV_MAX_Q_DEPTH),
+        MV_CRPB_Q_SZ            = (8 * MV_MAX_Q_DEPTH),
+        MV_MAX_SG_CT            = 176,
+        MV_SG_TBL_SZ            = (16 * MV_MAX_SG_CT),
+        MV_PORT_PRIV_DMA_SZ     = (MV_CRQB_Q_SZ + MV_CRPB_Q_SZ + MV_SG_TBL_SZ),
+
+        /* Our DMA boundary is determined by an ePRD being unable to handle
+         * anything larger than 64KB
+         */
+        MV_DMA_BOUNDARY         = 0xffffU,
 
         MV_PORTS_PER_HC         = 4,
         /* == (port / MV_PORTS_PER_HC) to determine HC from 0-7 port */
         MV_PORT_HC_SHIFT        = 2,
-        /* == (port % MV_PORTS_PER_HC) to determine port from 0-7 port */
+        /* == (port % MV_PORTS_PER_HC) to determine hard port from 0-7 port */
         MV_PORT_MASK            = 3,
 
         /* Host Flags */
         MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
         MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
-        MV_FLAG_BDMA            = (1 << 28),  /* Basic DMA */
+        MV_FLAG_GLBL_SFT_RST    = (1 << 28),  /* Global Soft Reset support */
+        MV_COMMON_FLAGS         = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO),
+        MV_6XXX_FLAGS           = (MV_FLAG_IRQ_COALESCE | 
+                                   MV_FLAG_GLBL_SFT_RST),
 
         chip_504x               = 0,
         chip_508x               = 1,
         chip_604x               = 2,
         chip_608x               = 3,
 
+        CRQB_FLAG_READ          = (1 << 0),
+        CRQB_TAG_SHIFT          = 1,
+        CRQB_CMD_ADDR_SHIFT     = 8,
+        CRQB_CMD_CS             = (0x2 << 11),
+        CRQB_CMD_LAST           = (1 << 15),
+
+        CRPB_FLAG_STATUS_SHIFT  = 8,
+
+        EPRD_FLAG_END_OF_TBL    = (1 << 31),
+
         /* PCI interface registers */
 
+        PCI_COMMAND_OFS         = 0xc00,
+
         PCI_MAIN_CMD_STS_OFS    = 0xd30,
         STOP_PCI_MASTER         = (1 << 2),
         PCI_MASTER_EMPTY        = (1 << 3),
@@ -111,20 +141,13 @@ enum {
         HC_CFG_OFS              = 0,
 
         HC_IRQ_CAUSE_OFS        = 0x14,
-        CRBP_DMA_DONE           = (1 << 0),     /* shift by port # */
+        CRPB_DMA_DONE           = (1 << 0),     /* shift by port # */
         HC_IRQ_COAL             = (1 << 4),     /* IRQ coalescing */
         DEV_IRQ                 = (1 << 8),     /* shift by port # */
 
         /* Shadow block registers */
-        SHD_PIO_DATA_OFS        = 0x100,
-        SHD_FEA_ERR_OFS         = 0x104,
-        SHD_SECT_CNT_OFS        = 0x108,
-        SHD_LBA_L_OFS           = 0x10C,
-        SHD_LBA_M_OFS           = 0x110,
-        SHD_LBA_H_OFS           = 0x114,
-        SHD_DEV_HD_OFS          = 0x118,
-        SHD_CMD_STA_OFS         = 0x11C,
-        SHD_CTL_AST_OFS         = 0x120,
+        SHD_BLK_OFS             = 0x100,
+        SHD_CTL_AST_OFS         = 0x20,         /* ofs from SHD_BLK_OFS */
 
         /* SATA registers */
         SATA_STATUS_OFS         = 0x300,  /* ctrl, err regs follow status */
@@ -132,6 +155,11 @@ enum {
 
         /* Port registers */
         EDMA_CFG_OFS            = 0,
+        EDMA_CFG_Q_DEPTH        = 0,                    /* queueing disabled */
+        EDMA_CFG_NCQ            = (1 << 5),
+        EDMA_CFG_NCQ_GO_ON_ERR  = (1 << 14),            /* continue on error */
+        EDMA_CFG_RD_BRST_EXT    = (1 << 11),            /* read burst 512B */
+        EDMA_CFG_WR_BUFF_LEN    = (1 << 13),            /* write buffer 512B */
 
         EDMA_ERR_IRQ_CAUSE_OFS  = 0x8,
         EDMA_ERR_IRQ_MASK_OFS   = 0xc,
@@ -161,33 +189,85 @@ enum {
                                    EDMA_ERR_LNK_DATA_TX | 
                                    EDMA_ERR_TRANS_PROTO),
 
+        EDMA_REQ_Q_BASE_HI_OFS  = 0x10,
+        EDMA_REQ_Q_IN_PTR_OFS   = 0x14,         /* also contains BASE_LO */
+        EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
+
+        EDMA_REQ_Q_OUT_PTR_OFS  = 0x18,
+        EDMA_REQ_Q_PTR_SHIFT    = 5,
+
+        EDMA_RSP_Q_BASE_HI_OFS  = 0x1c,
+        EDMA_RSP_Q_IN_PTR_OFS   = 0x20,
+        EDMA_RSP_Q_OUT_PTR_OFS  = 0x24,         /* also contains BASE_LO */
+        EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
+        EDMA_RSP_Q_PTR_SHIFT    = 3,
+
         EDMA_CMD_OFS            = 0x28,
         EDMA_EN                 = (1 << 0),
         EDMA_DS                 = (1 << 1),
         ATA_RST                 = (1 << 2),
 
-        /* BDMA is 6xxx part only */
-        BDMA_CMD_OFS            = 0x224,
-        BDMA_START              = (1 << 0),
+        /* Host private flags (hp_flags) */
+        MV_HP_FLAG_MSI          = (1 << 0),
 
-        MV_UNDEF                = 0,
+        /* Port private flags (pp_flags) */
+        MV_PP_FLAG_EDMA_EN      = (1 << 0),
+        MV_PP_FLAG_EDMA_DS_ACT  = (1 << 1),
 };
 
-struct mv_port_priv {
+/* Command ReQuest Block: 32B */
+struct mv_crqb {
+        u32                     sg_addr;
+        u32                     sg_addr_hi;
+        u16                     ctrl_flags;
+        u16                     ata_cmd[11];
+};
 
+/* Command ResPonse Block: 8B */
+struct mv_crpb {
+        u16                     id;
+        u16                     flags;
+        u32                     tmstmp;
 };
 
-struct mv_host_priv {
+/* EDMA Physical Region Descriptor (ePRD); A.K.A. SG */
+struct mv_sg {
+        u32                     addr;
+        u32                     flags_size;
+        u32                     addr_hi;
+        u32                     reserved;
+};
 
+struct mv_port_priv {
+        struct mv_crqb          *crqb;
+        dma_addr_t              crqb_dma;
+        struct mv_crpb          *crpb;
+        dma_addr_t              crpb_dma;
+        struct mv_sg            *sg_tbl;
+        dma_addr_t              sg_tbl_dma;
+
+        unsigned                req_producer;           /* cp of req_in_ptr */
+        unsigned                rsp_consumer;           /* cp of rsp_out_ptr */
+        u32                     pp_flags;
+};
+
+struct mv_host_priv {
+        u32                     hp_flags;
 };
 
 static void mv_irq_clear(struct ata_port *ap);
 static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in);
 static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
+static u8 mv_check_err(struct ata_port *ap);
 static void mv_phy_reset(struct ata_port *ap);
-static int mv_master_reset(void __iomem *mmio_base);
+static void mv_host_stop(struct ata_host_set *host_set);
+static int mv_port_start(struct ata_port *ap);
+static void mv_port_stop(struct ata_port *ap);
+static void mv_qc_prep(struct ata_queued_cmd *qc);
+static int mv_qc_issue(struct ata_queued_cmd *qc);
 static irqreturn_t mv_interrupt(int irq, void *dev_instance,
                                 struct pt_regs *regs);
+static void mv_eng_timeout(struct ata_port *ap);
 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 
 static Scsi_Host_Template mv_sht = {
@@ -196,13 +276,13 @@ static Scsi_Host_Template mv_sht = {
         .ioctl                  = ata_scsi_ioctl,
         .queuecommand           = ata_scsi_queuecmd,
         .eh_strategy_handler    = ata_scsi_error,
-        .can_queue              = ATA_DEF_QUEUE,
+        .can_queue              = MV_USE_Q_DEPTH,
         .this_id                = ATA_SHT_THIS_ID,
-        .sg_tablesize           = MV_UNDEF,
+        .sg_tablesize           = MV_MAX_SG_CT,
         .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
-        .use_clustering         = MV_UNDEF,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
         .proc_name              = DRV_NAME,
         .dma_boundary           = MV_DMA_BOUNDARY,
         .slave_configure        = ata_scsi_slave_config,
@@ -216,15 +296,16 @@ static struct ata_port_operations mv_ops = {
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
+        .check_err              = mv_check_err,
         .exec_command           = ata_exec_command,
         .dev_select             = ata_std_dev_select,
 
         .phy_reset              = mv_phy_reset,
 
-        .qc_prep                = ata_qc_prep,
-        .qc_issue               = ata_qc_issue_prot,
+        .qc_prep                = mv_qc_prep,
+        .qc_issue               = mv_qc_issue,
 
-        .eng_timeout            = ata_eng_timeout,
+        .eng_timeout            = mv_eng_timeout,
 
         .irq_handler            = mv_interrupt,
         .irq_clear              = mv_irq_clear,
@@ -232,46 +313,39 @@ static struct ata_port_operations mv_ops = {
         .scr_read               = mv_scr_read,
         .scr_write              = mv_scr_write,
 
-        .port_start             = ata_port_start,
-        .port_stop              = ata_port_stop,
-        .host_stop              = ata_host_stop,
+        .port_start             = mv_port_start,
+        .port_stop              = mv_port_stop,
+        .host_stop              = mv_host_stop,
 };
 
 static struct ata_port_info mv_port_info[] = {
         {  /* chip_504x */
                 .sht            = &mv_sht,
-                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO),
-                .pio_mask       = 0x1f, /* pio4-0 */
-                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .host_flags     = MV_COMMON_FLAGS,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .udma_mask      = 0,    /* 0x7f (udma0-6 disabled for now) */
                 .port_ops       = &mv_ops,
         },
         {  /* chip_508x */
                 .sht            = &mv_sht,
-                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO | 
-                                   MV_FLAG_DUAL_HC),
-                .pio_mask       = 0x1f, /* pio4-0 */
-                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .host_flags     = (MV_COMMON_FLAGS | MV_FLAG_DUAL_HC),
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .udma_mask      = 0,    /* 0x7f (udma0-6 disabled for now) */
                 .port_ops       = &mv_ops,
         },
         {  /* chip_604x */
                 .sht            = &mv_sht,
-                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO | 
-                                   MV_FLAG_IRQ_COALESCE | MV_FLAG_BDMA),
-                .pio_mask       = 0x1f, /* pio4-0 */
-                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .host_flags     = (MV_COMMON_FLAGS | MV_6XXX_FLAGS),
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .udma_mask      = 0x7f, /* udma0-6 */
                 .port_ops       = &mv_ops,
         },
         {  /* chip_608x */
                 .sht            = &mv_sht,
-                .host_flags     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                   ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
-                                   MV_FLAG_IRQ_COALESCE | MV_FLAG_DUAL_HC |
-                                   MV_FLAG_BDMA),
-                .pio_mask       = 0x1f, /* pio4-0 */
-                .udma_mask      = 0,    /* 0x7f (udma6-0 disabled for now) */
+                .host_flags     = (MV_COMMON_FLAGS | MV_6XXX_FLAGS | 
+                                   MV_FLAG_DUAL_HC),
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .udma_mask      = 0x7f, /* udma0-6 */
                 .port_ops       = &mv_ops,
         },
 };
@@ -306,12 +380,6 @@ static inline void writelfl(unsigned long data, void __iomem *addr)
         (void) readl(addr);     /* flush to avoid PCI posted write */
 }
 
-static inline void __iomem *mv_port_addr_to_hc_base(void __iomem *port_mmio)
-{
-        return ((void __iomem *)((unsigned long)port_mmio & 
-                                 (unsigned long)SATAHC_MASK));
-}
-
 static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
 {
         return (base + MV_SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
@@ -329,24 +397,150 @@ static inline void __iomem *mv_ap_base(struct ata_port *ap)
         return mv_port_base(ap->host_set->mmio_base, ap->port_no);
 }
 
-static inline int mv_get_hc_count(unsigned long flags)
+static inline int mv_get_hc_count(unsigned long hp_flags)
 {
-        return ((flags & MV_FLAG_DUAL_HC) ? 2 : 1);
+        return ((hp_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
 }
 
-static inline int mv_is_edma_active(struct ata_port *ap)
+static void mv_irq_clear(struct ata_port *ap)
+{
+}
+
+/**
+ *      mv_start_dma - Enable eDMA engine
+ *      @base: port base address
+ *      @pp: port private data
+ *
+ *      Verify the local cache of the eDMA state is accurate with an
+ *      assert.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_start_dma(void __iomem *base, struct mv_port_priv *pp)
+{
+        if (!(MV_PP_FLAG_EDMA_EN & pp->pp_flags)) {
+                writelfl(EDMA_EN, base + EDMA_CMD_OFS);
+                pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
+        }
+        assert(EDMA_EN & readl(base + EDMA_CMD_OFS));
+}
+
+/**
+ *      mv_stop_dma - Disable eDMA engine
+ *      @ap: ATA channel to manipulate
+ *
+ *      Verify the local cache of the eDMA state is accurate with an
+ *      assert.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_stop_dma(struct ata_port *ap)
 {
         void __iomem *port_mmio = mv_ap_base(ap);
-        return (EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
+        struct mv_port_priv *pp = ap->private_data;
+        u32 reg;
+        int i;
+
+        if (MV_PP_FLAG_EDMA_EN & pp->pp_flags) {
+                /* Disable EDMA if active.   The disable bit auto clears.
+                 */
+                writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
+                pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
+        } else {
+                assert(!(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS)));
+        }
+        
+        /* now properly wait for the eDMA to stop */
+        for (i = 1000; i > 0; i--) {
+                reg = readl(port_mmio + EDMA_CMD_OFS);
+                if (!(EDMA_EN & reg)) {
+                        break;
+                }
+                udelay(100);
+        }
+
+        if (EDMA_EN & reg) {
+                printk(KERN_ERR "ata%u: Unable to stop eDMA\n", ap->id);
+                /* FIXME: Consider doing a reset here to recover */
+        }
 }
 
-static inline int mv_port_bdma_capable(struct ata_port *ap)
+#ifdef ATA_DEBUG
+static void mv_dump_mem(void __iomem *start, unsigned bytes)
 {
-        return (ap->flags & MV_FLAG_BDMA);
+        int b, w;
+        for (b = 0; b < bytes; ) {
+                DPRINTK("%p: ", start + b);
+                for (w = 0; b < bytes && w < 4; w++) {
+                        printk("%08x ",readl(start + b));
+                        b += sizeof(u32);
+                }
+                printk("\n");
+        }
 }
+#endif
 
-static void mv_irq_clear(struct ata_port *ap)
+static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
+{
+#ifdef ATA_DEBUG
+        int b, w;
+        u32 dw;
+        for (b = 0; b < bytes; ) {
+                DPRINTK("%02x: ", b);
+                for (w = 0; b < bytes && w < 4; w++) {
+                        (void) pci_read_config_dword(pdev,b,&dw);
+                        printk("%08x ",dw);
+                        b += sizeof(u32);
+                }
+                printk("\n");
+        }
+#endif
+}
+static void mv_dump_all_regs(void __iomem *mmio_base, int port,
+                             struct pci_dev *pdev)
 {
+#ifdef ATA_DEBUG
+        void __iomem *hc_base = mv_hc_base(mmio_base, 
+                                           port >> MV_PORT_HC_SHIFT);
+        void __iomem *port_base;
+        int start_port, num_ports, p, start_hc, num_hcs, hc;
+
+        if (0 > port) {
+                start_hc = start_port = 0;
+                num_ports = 8;          /* shld be benign for 4 port devs */
+                num_hcs = 2;
+        } else {
+                start_hc = port >> MV_PORT_HC_SHIFT;
+                start_port = port;
+                num_ports = num_hcs = 1;
+        }
+        DPRINTK("All registers for port(s) %u-%u:\n", start_port, 
+                num_ports > 1 ? num_ports - 1 : start_port);
+
+        if (NULL != pdev) {
+                DPRINTK("PCI config space regs:\n");
+                mv_dump_pci_cfg(pdev, 0x68);
+        }
+        DPRINTK("PCI regs:\n");
+        mv_dump_mem(mmio_base+0xc00, 0x3c);
+        mv_dump_mem(mmio_base+0xd00, 0x34);
+        mv_dump_mem(mmio_base+0xf00, 0x4);
+        mv_dump_mem(mmio_base+0x1d00, 0x6c);
+        for (hc = start_hc; hc < start_hc + num_hcs; hc++) {
+                hc_base = mv_hc_base(mmio_base, port >> MV_PORT_HC_SHIFT);
+                DPRINTK("HC regs (HC %i):\n", hc);
+                mv_dump_mem(hc_base, 0x1c);
+        }
+        for (p = start_port; p < start_port + num_ports; p++) {
+                port_base = mv_port_base(mmio_base, p);
+                DPRINTK("EDMA regs (port %i):\n",p);
+                mv_dump_mem(port_base, 0x54);
+                DPRINTK("SATA regs (port %i):\n",p);
+                mv_dump_mem(port_base+0x300, 0x60);
+        }
+#endif
 }
 
 static unsigned int mv_scr_offset(unsigned int sc_reg_in)
@@ -389,30 +583,37 @@ static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
         }
 }
 
-static int mv_master_reset(void __iomem *mmio_base)
+/**
+ *      mv_global_soft_reset - Perform the 6xxx global soft reset
+ *      @mmio_base: base address of the HBA
+ *
+ *      This routine only applies to 6xxx parts.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static int mv_global_soft_reset(void __iomem *mmio_base)
 {
         void __iomem *reg = mmio_base + PCI_MAIN_CMD_STS_OFS;
         int i, rc = 0;
         u32 t;
 
-        VPRINTK("ENTER\n");
-
         /* Following procedure defined in PCI "main command and status
          * register" table.
          */
         t = readl(reg);
         writel(t | STOP_PCI_MASTER, reg);
 
-        for (i = 0; i < 100; i++) {
-                msleep(10);
+        for (i = 0; i < 1000; i++) {
+                udelay(1);
                 t = readl(reg);
                 if (PCI_MASTER_EMPTY & t) {
                         break;
                 }
         }
         if (!(PCI_MASTER_EMPTY & t)) {
-                printk(KERN_ERR DRV_NAME "PCI master won't flush\n");
-                rc = 1;         /* broken HW? */
+                printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
+                rc = 1;
                 goto done;
         }
 
@@ -425,39 +626,398 @@ static int mv_master_reset(void __iomem *mmio_base)
         } while (!(GLOB_SFT_RST & t) && (i-- > 0));
 
         if (!(GLOB_SFT_RST & t)) {
-                printk(KERN_ERR DRV_NAME "can't set global reset\n");
-                rc = 1;         /* broken HW? */
+                printk(KERN_ERR DRV_NAME ": can't set global reset\n");
+                rc = 1;
                 goto done;
         }
 
-        /* clear reset */
+        /* clear reset and *reenable the PCI master* (not mentioned in spec) */
         i = 5;
         do {
-                writel(t & ~GLOB_SFT_RST, reg);
+                writel(t & ~(GLOB_SFT_RST | STOP_PCI_MASTER), reg);
                 t = readl(reg);
                 udelay(1);
         } while ((GLOB_SFT_RST & t) && (i-- > 0));
 
         if (GLOB_SFT_RST & t) {
-                printk(KERN_ERR DRV_NAME "can't clear global reset\n");
-                rc = 1;         /* broken HW? */
+                printk(KERN_ERR DRV_NAME ": can't clear global reset\n");
+                rc = 1;
         }
-
- done:
-        VPRINTK("EXIT, rc = %i\n", rc);
+done:
         return rc;
 }
 
-static void mv_err_intr(struct ata_port *ap)
+/**
+ *      mv_host_stop - Host specific cleanup/stop routine.
+ *      @host_set: host data structure
+ *
+ *      Disable ints, cleanup host memory, call general purpose
+ *      host_stop.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_host_stop(struct ata_host_set *host_set)
 {
-        void __iomem *port_mmio;
-        u32 edma_err_cause, serr = 0;
+        struct mv_host_priv *hpriv = host_set->private_data;
+        struct pci_dev *pdev = to_pci_dev(host_set->dev);
+
+        if (hpriv->hp_flags & MV_HP_FLAG_MSI) {
+                pci_disable_msi(pdev);
+        } else {
+                pci_intx(pdev, 0);
+        }
+        kfree(hpriv);
+        ata_host_stop(host_set);
+}
+
+/**
+ *      mv_port_start - Port specific init/start routine.
+ *      @ap: ATA channel to manipulate
+ *
+ *      Allocate and point to DMA memory, init port private memory,
+ *      zero indices.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static int mv_port_start(struct ata_port *ap)
+{
+        struct device *dev = ap->host_set->dev;
+        struct mv_port_priv *pp;
+        void __iomem *port_mmio = mv_ap_base(ap);
+        void *mem;
+        dma_addr_t mem_dma;
+
+        pp = kmalloc(sizeof(*pp), GFP_KERNEL);
+        if (!pp) {
+                return -ENOMEM;
+        }
+        memset(pp, 0, sizeof(*pp));
+
+        mem = dma_alloc_coherent(dev, MV_PORT_PRIV_DMA_SZ, &mem_dma, 
+                                 GFP_KERNEL);
+        if (!mem) {
+                kfree(pp);
+                return -ENOMEM;
+        }
+        memset(mem, 0, MV_PORT_PRIV_DMA_SZ);
+
+        /* First item in chunk of DMA memory: 
+         * 32-slot command request table (CRQB), 32 bytes each in size
+         */
+        pp->crqb = mem;
+        pp->crqb_dma = mem_dma;
+        mem += MV_CRQB_Q_SZ;
+        mem_dma += MV_CRQB_Q_SZ;
+
+        /* Second item: 
+         * 32-slot command response table (CRPB), 8 bytes each in size
+         */
+        pp->crpb = mem;
+        pp->crpb_dma = mem_dma;
+        mem += MV_CRPB_Q_SZ;
+        mem_dma += MV_CRPB_Q_SZ;
+
+        /* Third item:
+         * Table of scatter-gather descriptors (ePRD), 16 bytes each
+         */
+        pp->sg_tbl = mem;
+        pp->sg_tbl_dma = mem_dma;
+
+        writelfl(EDMA_CFG_Q_DEPTH | EDMA_CFG_RD_BRST_EXT | 
+                 EDMA_CFG_WR_BUFF_LEN, port_mmio + EDMA_CFG_OFS);
+
+        writel((pp->crqb_dma >> 16) >> 16, port_mmio + EDMA_REQ_Q_BASE_HI_OFS);
+        writelfl(pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK, 
+                 port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
+
+        writelfl(0, port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
+        writelfl(0, port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
+
+        writel((pp->crpb_dma >> 16) >> 16, port_mmio + EDMA_RSP_Q_BASE_HI_OFS);
+        writelfl(pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK, 
+                 port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
+
+        pp->req_producer = pp->rsp_consumer = 0;
+
+        /* Don't turn on EDMA here...do it before DMA commands only.  Else
+         * we'll be unable to send non-data, PIO, etc due to restricted access
+         * to shadow regs.
+         */
+        ap->private_data = pp;
+        return 0;
+}
+
+/**
+ *      mv_port_stop - Port specific cleanup/stop routine.
+ *      @ap: ATA channel to manipulate
+ *
+ *      Stop DMA, cleanup port memory.
+ *
+ *      LOCKING:
+ *      This routine uses the host_set lock to protect the DMA stop.
+ */
+static void mv_port_stop(struct ata_port *ap)
+{
+        struct device *dev = ap->host_set->dev;
+        struct mv_port_priv *pp = ap->private_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ap->host_set->lock, flags);
+        mv_stop_dma(ap);
+        spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+        ap->private_data = NULL;
+        dma_free_coherent(dev, MV_PORT_PRIV_DMA_SZ, pp->crpb, pp->crpb_dma);
+        kfree(pp);
+}
+
+/**
+ *      mv_fill_sg - Fill out the Marvell ePRD (scatter gather) entries
+ *      @qc: queued command whose SG list to source from
+ *
+ *      Populate the SG list and mark the last entry.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_fill_sg(struct ata_queued_cmd *qc)
+{
+        struct mv_port_priv *pp = qc->ap->private_data;
+        unsigned int i;
+
+        for (i = 0; i < qc->n_elem; i++) {
+                u32 sg_len;
+                dma_addr_t addr;
+
+                addr = sg_dma_address(&qc->sg[i]);
+                sg_len = sg_dma_len(&qc->sg[i]);
+
+                pp->sg_tbl[i].addr = cpu_to_le32(addr & 0xffffffff);
+                pp->sg_tbl[i].addr_hi = cpu_to_le32((addr >> 16) >> 16);
+                assert(0 == (sg_len & ~MV_DMA_BOUNDARY));
+                pp->sg_tbl[i].flags_size = cpu_to_le32(sg_len);
+        }
+        if (0 < qc->n_elem) {
+                pp->sg_tbl[qc->n_elem - 1].flags_size |= EPRD_FLAG_END_OF_TBL;
+        }
+}
+
+static inline unsigned mv_inc_q_index(unsigned *index)
+{
+        *index = (*index + 1) & MV_MAX_Q_DEPTH_MASK;
+        return *index;
+}
+
+static inline void mv_crqb_pack_cmd(u16 *cmdw, u8 data, u8 addr, unsigned last)
+{
+        *cmdw = data | (addr << CRQB_CMD_ADDR_SHIFT) | CRQB_CMD_CS |
+                (last ? CRQB_CMD_LAST : 0);
+}
 
-        /* bug here b/c we got an err int on a port we don't know about,
-         * so there's no way to clear it
+/**
+ *      mv_qc_prep - Host specific command preparation.
+ *      @qc: queued command to prepare
+ *
+ *      This routine simply redirects to the general purpose routine
+ *      if command is not DMA.  Else, it handles prep of the CRQB
+ *      (command request block), does some sanity checking, and calls
+ *      the SG load routine.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_qc_prep(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct mv_port_priv *pp = ap->private_data;
+        u16 *cw;
+        struct ata_taskfile *tf;
+        u16 flags = 0;
+
+        if (ATA_PROT_DMA != qc->tf.protocol) {
+                return;
+        }
+
+        /* the req producer index should be the same as we remember it */
+        assert(((readl(mv_ap_base(qc->ap) + EDMA_REQ_Q_IN_PTR_OFS) >> 
+                 EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
+               pp->req_producer);
+
+        /* Fill in command request block
          */
-        BUG_ON(NULL == ap);
-        port_mmio = mv_ap_base(ap);
+        if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
+                flags |= CRQB_FLAG_READ;
+        }
+        assert(MV_MAX_Q_DEPTH > qc->tag);
+        flags |= qc->tag << CRQB_TAG_SHIFT;
+
+        pp->crqb[pp->req_producer].sg_addr = 
+                cpu_to_le32(pp->sg_tbl_dma & 0xffffffff);
+        pp->crqb[pp->req_producer].sg_addr_hi = 
+                cpu_to_le32((pp->sg_tbl_dma >> 16) >> 16);
+        pp->crqb[pp->req_producer].ctrl_flags = cpu_to_le16(flags);
+
+        cw = &pp->crqb[pp->req_producer].ata_cmd[0];
+        tf = &qc->tf;
+
+        /* Sadly, the CRQB cannot accomodate all registers--there are
+         * only 11 bytes...so we must pick and choose required
+         * registers based on the command.  So, we drop feature and
+         * hob_feature for [RW] DMA commands, but they are needed for
+         * NCQ.  NCQ will drop hob_nsect.
+         */
+        switch (tf->command) {
+        case ATA_CMD_READ:
+        case ATA_CMD_READ_EXT:
+        case ATA_CMD_WRITE:
+        case ATA_CMD_WRITE_EXT:
+                mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
+                break;
+#ifdef LIBATA_NCQ               /* FIXME: remove this line when NCQ added */
+        case ATA_CMD_FPDMA_READ:
+        case ATA_CMD_FPDMA_WRITE:
+                mv_crqb_pack_cmd(cw++, tf->hob_feature, ATA_REG_FEATURE, 0); 
+                mv_crqb_pack_cmd(cw++, tf->feature, ATA_REG_FEATURE, 0);
+                break;
+#endif                          /* FIXME: remove this line when NCQ added */
+        default:
+                /* The only other commands EDMA supports in non-queued and
+                 * non-NCQ mode are: [RW] STREAM DMA and W DMA FUA EXT, none
+                 * of which are defined/used by Linux.  If we get here, this
+                 * driver needs work.
+                 *
+                 * FIXME: modify libata to give qc_prep a return value and
+                 * return error here.
+                 */
+                BUG_ON(tf->command);
+                break;
+        }
+        mv_crqb_pack_cmd(cw++, tf->nsect, ATA_REG_NSECT, 0);
+        mv_crqb_pack_cmd(cw++, tf->hob_lbal, ATA_REG_LBAL, 0);
+        mv_crqb_pack_cmd(cw++, tf->lbal, ATA_REG_LBAL, 0);
+        mv_crqb_pack_cmd(cw++, tf->hob_lbam, ATA_REG_LBAM, 0);
+        mv_crqb_pack_cmd(cw++, tf->lbam, ATA_REG_LBAM, 0);
+        mv_crqb_pack_cmd(cw++, tf->hob_lbah, ATA_REG_LBAH, 0);
+        mv_crqb_pack_cmd(cw++, tf->lbah, ATA_REG_LBAH, 0);
+        mv_crqb_pack_cmd(cw++, tf->device, ATA_REG_DEVICE, 0);
+        mv_crqb_pack_cmd(cw++, tf->command, ATA_REG_CMD, 1);    /* last */
+
+        if (!(qc->flags & ATA_QCFLAG_DMAMAP)) {
+                return;
+        }
+        mv_fill_sg(qc);
+}
+
+/**
+ *      mv_qc_issue - Initiate a command to the host
+ *      @qc: queued command to start
+ *
+ *      This routine simply redirects to the general purpose routine
+ *      if command is not DMA.  Else, it sanity checks our local
+ *      caches of the request producer/consumer indices then enables
+ *      DMA and bumps the request producer index.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static int mv_qc_issue(struct ata_queued_cmd *qc)
+{
+        void __iomem *port_mmio = mv_ap_base(qc->ap);
+        struct mv_port_priv *pp = qc->ap->private_data;
+        u32 in_ptr;
+
+        if (ATA_PROT_DMA != qc->tf.protocol) {
+                /* We're about to send a non-EDMA capable command to the
+                 * port.  Turn off EDMA so there won't be problems accessing
+                 * shadow block, etc registers.
+                 */
+                mv_stop_dma(qc->ap);
+                return ata_qc_issue_prot(qc);
+        }
+
+        in_ptr = readl(port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
+
+        /* the req producer index should be the same as we remember it */
+        assert(((in_ptr >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
+               pp->req_producer);
+        /* until we do queuing, the queue should be empty at this point */
+        assert(((in_ptr >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
+               ((readl(port_mmio + EDMA_REQ_Q_OUT_PTR_OFS) >> 
+                 EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK));
+
+        mv_inc_q_index(&pp->req_producer);      /* now incr producer index */
+
+        mv_start_dma(port_mmio, pp);
+
+        /* and write the request in pointer to kick the EDMA to life */
+        in_ptr &= EDMA_REQ_Q_BASE_LO_MASK;
+        in_ptr |= pp->req_producer << EDMA_REQ_Q_PTR_SHIFT;
+        writelfl(in_ptr, port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
+
+        return 0;
+}
+
+/**
+ *      mv_get_crpb_status - get status from most recently completed cmd
+ *      @ap: ATA channel to manipulate
+ *
+ *      This routine is for use when the port is in DMA mode, when it
+ *      will be using the CRPB (command response block) method of
+ *      returning command completion information.  We assert indices
+ *      are good, grab status, and bump the response consumer index to
+ *      prove that we're up to date.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static u8 mv_get_crpb_status(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        struct mv_port_priv *pp = ap->private_data;
+        u32 out_ptr;
+
+        out_ptr = readl(port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
+
+        /* the response consumer index should be the same as we remember it */
+        assert(((out_ptr >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) == 
+               pp->rsp_consumer);
+
+        /* increment our consumer index... */
+        pp->rsp_consumer = mv_inc_q_index(&pp->rsp_consumer);
+        
+        /* and, until we do NCQ, there should only be 1 CRPB waiting */
+        assert(((readl(port_mmio + EDMA_RSP_Q_IN_PTR_OFS) >> 
+                 EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) == 
+               pp->rsp_consumer);
+
+        /* write out our inc'd consumer index so EDMA knows we're caught up */
+        out_ptr &= EDMA_RSP_Q_BASE_LO_MASK;
+        out_ptr |= pp->rsp_consumer << EDMA_RSP_Q_PTR_SHIFT;
+        writelfl(out_ptr, port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
+
+        /* Return ATA status register for completed CRPB */
+        return (pp->crpb[pp->rsp_consumer].flags >> CRPB_FLAG_STATUS_SHIFT);
+}
+
+/**
+ *      mv_err_intr - Handle error interrupts on the port
+ *      @ap: ATA channel to manipulate
+ *
+ *      In most cases, just clear the interrupt and move on.  However,
+ *      some cases require an eDMA reset, which is done right before
+ *      the COMRESET in mv_phy_reset().  The SERR case requires a
+ *      clear of pending errors in the SATA SERROR register.  Finally,
+ *      if the port disabled DMA, update our cached copy to match.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_err_intr(struct ata_port *ap)
+{
+        void __iomem *port_mmio = mv_ap_base(ap);
+        u32 edma_err_cause, serr = 0;
 
         edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
 
@@ -465,8 +1025,12 @@ static void mv_err_intr(struct ata_port *ap)
                 serr = scr_read(ap, SCR_ERROR);
                 scr_write_flush(ap, SCR_ERROR, serr);
         }
-        DPRINTK("port %u error; EDMA err cause: 0x%08x SERR: 0x%08x\n", 
-                ap->port_no, edma_err_cause, serr);
+        if (EDMA_ERR_SELF_DIS & edma_err_cause) {
+                struct mv_port_priv *pp = ap->private_data;
+                pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
+        }
+        DPRINTK(KERN_ERR "ata%u: port error; EDMA err cause: 0x%08x "
+                "SERR: 0x%08x\n", ap->id, edma_err_cause, serr);
 
         /* Clear EDMA now that SERR cleanup done */
         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
@@ -477,7 +1041,21 @@ static void mv_err_intr(struct ata_port *ap)
         }
 }
 
-/* Handle any outstanding interrupts in a single SATAHC 
+/**
+ *      mv_host_intr - Handle all interrupts on the given host controller
+ *      @host_set: host specific structure
+ *      @relevant: port error bits relevant to this host controller
+ *      @hc: which host controller we're to look at
+ *
+ *      Read then write clear the HC interrupt status then walk each
+ *      port connected to the HC and see if it needs servicing.  Port
+ *      success ints are reported in the HC interrupt status reg, the
+ *      port error ints are reported in the higher level main
+ *      interrupt status register and thus are passed in via the
+ *      'relevant' argument.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
  */
 static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
                          unsigned int hc)
@@ -487,8 +1065,8 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
         struct ata_port *ap;
         struct ata_queued_cmd *qc;
         u32 hc_irq_cause;
-        int shift, port, port0, hard_port;
-        u8 ata_status;
+        int shift, port, port0, hard_port, handled;
+        u8 ata_status = 0;
 
         if (hc == 0) {
                 port0 = 0;
@@ -499,7 +1077,7 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
         /* we'll need the HC success int register in most cases */
         hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
         if (hc_irq_cause) {
-                writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
+                writelfl(~hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
         }
 
         VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
@@ -508,35 +1086,38 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
         for (port = port0; port < port0 + MV_PORTS_PER_HC; port++) {
                 ap = host_set->ports[port];
                 hard_port = port & MV_PORT_MASK;        /* range 0-3 */
-                ata_status = 0xffU;
+                handled = 0;    /* ensure ata_status is set if handled++ */
 
-                if (((CRBP_DMA_DONE | DEV_IRQ) << hard_port) & hc_irq_cause) {
-                        BUG_ON(NULL == ap);
-                        /* rcv'd new resp, basic DMA complete, or ATA IRQ */
-                        /* This is needed to clear the ATA INTRQ.
-                         * FIXME: don't read the status reg in EDMA mode!
+                if ((CRPB_DMA_DONE << hard_port) & hc_irq_cause) {
+                        /* new CRPB on the queue; just one at a time until NCQ
+                         */
+                        ata_status = mv_get_crpb_status(ap);
+                        handled++;
+                } else if ((DEV_IRQ << hard_port) & hc_irq_cause) {
+                        /* received ATA IRQ; read the status reg to clear INTRQ
                          */
                         ata_status = readb((void __iomem *)
                                            ap->ioaddr.status_addr);
+                        handled++;
                 }
 
-                shift = port * 2;
+                shift = port << 1;              /* (port * 2) */
                 if (port >= MV_PORTS_PER_HC) {
                         shift++;        /* skip bit 8 in the HC Main IRQ reg */
                 }
                 if ((PORT0_ERR << shift) & relevant) {
                         mv_err_intr(ap);
-                        /* FIXME: smart to OR in ATA_ERR? */
+                        /* OR in ATA_ERR to ensure libata knows we took one */
                         ata_status = readb((void __iomem *)
                                            ap->ioaddr.status_addr) | ATA_ERR;
+                        handled++;
                 }
                 
-                if (ap) {
+                if (handled && ap) {
                         qc = ata_qc_from_tag(ap, ap->active_tag);
                         if (NULL != qc) {
                                 VPRINTK("port %u IRQ found for qc, "
                                         "ata_status 0x%x\n", port,ata_status);
-                                BUG_ON(0xffU == ata_status);
                                 /* mark qc status appropriately */
                                 ata_qc_complete(qc, ata_status);
                         }
@@ -545,17 +1126,30 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant,
         VPRINTK("EXIT\n");
 }
 
+/**
+ *      mv_interrupt - 
+ *      @irq: unused
+ *      @dev_instance: private data; in this case the host structure
+ *      @regs: unused
+ *
+ *      Read the read only register to determine if any host
+ *      controllers have pending interrupts.  If so, call lower level
+ *      routine to handle.  Also check for PCI errors which are only
+ *      reported here.
+ *
+ *      LOCKING: 
+ *      This routine holds the host_set lock while processing pending
+ *      interrupts.
+ */
 static irqreturn_t mv_interrupt(int irq, void *dev_instance,
                                 struct pt_regs *regs)
 {
         struct ata_host_set *host_set = dev_instance;
         unsigned int hc, handled = 0, n_hcs;
-        void __iomem *mmio;
+        void __iomem *mmio = host_set->mmio_base;
         u32 irq_stat;
 
-        mmio = host_set->mmio_base;
         irq_stat = readl(mmio + HC_MAIN_IRQ_CAUSE_OFS);
-        n_hcs = mv_get_hc_count(host_set->ports[0]->flags);
 
         /* check the cases where we either have nothing pending or have read
          * a bogus register value which can indicate HW removal or PCI fault
@@ -564,64 +1158,105 @@ static irqreturn_t mv_interrupt(int irq, void *dev_instance,
                 return IRQ_NONE;
         }
 
+        n_hcs = mv_get_hc_count(host_set->ports[0]->flags);
         spin_lock(&host_set->lock);
 
         for (hc = 0; hc < n_hcs; hc++) {
                 u32 relevant = irq_stat & (HC0_IRQ_PEND << (hc * HC_SHIFT));
                 if (relevant) {
                         mv_host_intr(host_set, relevant, hc);
-                        handled = 1;
+                        handled++;
                 }
         }
         if (PCI_ERR & irq_stat) {
-                /* FIXME: these are all masked by default, but still need
-                 * to recover from them properly.
-                 */
-        }
+                printk(KERN_ERR DRV_NAME ": PCI ERROR; PCI IRQ cause=0x%08x\n",
+                       readl(mmio + PCI_IRQ_CAUSE_OFS));
 
+                DPRINTK("All regs @ PCI error\n");
+                mv_dump_all_regs(mmio, -1, to_pci_dev(host_set->dev));
+
+                writelfl(0, mmio + PCI_IRQ_CAUSE_OFS);
+                handled++;
+        }
         spin_unlock(&host_set->lock);
 
         return IRQ_RETVAL(handled);
 }
 
+/**
+ *      mv_check_err - Return the error shadow register to caller.
+ *      @ap: ATA channel to manipulate
+ *
+ *      Marvell requires DMA to be stopped before accessing shadow
+ *      registers.  So we do that, then return the needed register.
+ *
+ *      LOCKING:
+ *      Inherited from caller.  FIXME: protect mv_stop_dma with lock?
+ */
+static u8 mv_check_err(struct ata_port *ap)
+{
+        mv_stop_dma(ap);                /* can't read shadow regs if DMA on */
+        return readb((void __iomem *) ap->ioaddr.error_addr);
+}
+
+/**
+ *      mv_phy_reset - Perform eDMA reset followed by COMRESET
+ *      @ap: ATA channel to manipulate
+ *
+ *      Part of this is taken from __sata_phy_reset and modified to
+ *      not sleep since this routine gets called from interrupt level.
+ *
+ *      LOCKING:
+ *      Inherited from caller.  This is coded to safe to call at
+ *      interrupt level, i.e. it does not sleep.
+ */
 static void mv_phy_reset(struct ata_port *ap)
 {
         void __iomem *port_mmio = mv_ap_base(ap);
         struct ata_taskfile tf;
         struct ata_device *dev = &ap->device[0];
-        u32 edma = 0, bdma;
+        unsigned long timeout;
 
         VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
 
-        edma = readl(port_mmio + EDMA_CMD_OFS);
-        if (EDMA_EN & edma) {
-                /* disable EDMA if active */
-                edma &= ~EDMA_EN;
-                writelfl(edma | EDMA_DS, port_mmio + EDMA_CMD_OFS);
-                udelay(1);
-        } else if (mv_port_bdma_capable(ap) &&
-                   (bdma = readl(port_mmio + BDMA_CMD_OFS)) & BDMA_START) {
-                /* disable BDMA if active */
-                writelfl(bdma & ~BDMA_START, port_mmio + BDMA_CMD_OFS);
-        }
+        mv_stop_dma(ap);
 
-        writelfl(edma | ATA_RST, port_mmio + EDMA_CMD_OFS);
+        writelfl(ATA_RST, port_mmio + EDMA_CMD_OFS);
         udelay(25);             /* allow reset propagation */
 
         /* Spec never mentions clearing the bit.  Marvell's driver does
          * clear the bit, however.
          */
-        writelfl(edma & ~ATA_RST, port_mmio + EDMA_CMD_OFS);
+        writelfl(0, port_mmio + EDMA_CMD_OFS);
 
-        VPRINTK("Done.  Now calling __sata_phy_reset()\n");
+        VPRINTK("S-regs after ATA_RST: SStat 0x%08x SErr 0x%08x "
+                "SCtrl 0x%08x\n", mv_scr_read(ap, SCR_STATUS),
+                mv_scr_read(ap, SCR_ERROR), mv_scr_read(ap, SCR_CONTROL));
 
         /* proceed to init communications via the scr_control reg */
-        __sata_phy_reset(ap);
+        scr_write_flush(ap, SCR_CONTROL, 0x301);
+        mdelay(1);
+        scr_write_flush(ap, SCR_CONTROL, 0x300);
+        timeout = jiffies + (HZ * 1);
+        do {
+                mdelay(10);
+                if ((scr_read(ap, SCR_STATUS) & 0xf) != 1)
+                        break;
+        } while (time_before(jiffies, timeout));
 
-        if (ap->flags & ATA_FLAG_PORT_DISABLED) {
-                VPRINTK("Port disabled pre-sig.  Exiting.\n");
+        VPRINTK("S-regs after PHY wake: SStat 0x%08x SErr 0x%08x "
+                "SCtrl 0x%08x\n", mv_scr_read(ap, SCR_STATUS),
+                mv_scr_read(ap, SCR_ERROR), mv_scr_read(ap, SCR_CONTROL));
+
+        if (sata_dev_present(ap)) {
+                ata_port_probe(ap);
+        } else {
+                printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n",
+                       ap->id, scr_read(ap, SCR_STATUS));
+                ata_port_disable(ap);
                 return;
         }
+        ap->cbl = ATA_CBL_SATA;
 
         tf.lbah = readb((void __iomem *) ap->ioaddr.lbah_addr);
         tf.lbam = readb((void __iomem *) ap->ioaddr.lbam_addr);
@@ -636,37 +1271,118 @@ static void mv_phy_reset(struct ata_port *ap)
         VPRINTK("EXIT\n");
 }
 
-static void mv_port_init(struct ata_ioports *port, unsigned long base)
+/**
+ *      mv_eng_timeout - Routine called by libata when SCSI times out I/O
+ *      @ap: ATA channel to manipulate
+ *
+ *      Intent is to clear all pending error conditions, reset the
+ *      chip/bus, fail the command, and move on.
+ *
+ *      LOCKING:
+ *      This routine holds the host_set lock while failing the command.
+ */
+static void mv_eng_timeout(struct ata_port *ap)
+{
+        struct ata_queued_cmd *qc;
+        unsigned long flags;
+
+        printk(KERN_ERR "ata%u: Entering mv_eng_timeout\n",ap->id);
+        DPRINTK("All regs @ start of eng_timeout\n");
+        mv_dump_all_regs(ap->host_set->mmio_base, ap->port_no, 
+                         to_pci_dev(ap->host_set->dev));
+
+        qc = ata_qc_from_tag(ap, ap->active_tag);
+        printk(KERN_ERR "mmio_base %p ap %p qc %p scsi_cmnd %p &cmnd %p\n",
+               ap->host_set->mmio_base, ap, qc, qc->scsicmd, 
+               &qc->scsicmd->cmnd);
+
+        mv_err_intr(ap);
+        mv_phy_reset(ap);
+
+        if (!qc) {
+                printk(KERN_ERR "ata%u: BUG: timeout without command\n",
+                       ap->id);
+        } else {
+                /* hack alert!  We cannot use the supplied completion
+                 * function from inside the ->eh_strategy_handler() thread.
+                 * libata is the only user of ->eh_strategy_handler() in
+                 * any kernel, so the default scsi_done() assumes it is
+                 * not being called from the SCSI EH.
+                 */
+                spin_lock_irqsave(&ap->host_set->lock, flags);
+                qc->scsidone = scsi_finish_command;
+                ata_qc_complete(qc, ATA_ERR);
+                spin_unlock_irqrestore(&ap->host_set->lock, flags);
+        }
+}
+
+/**
+ *      mv_port_init - Perform some early initialization on a single port.
+ *      @port: libata data structure storing shadow register addresses
+ *      @port_mmio: base address of the port
+ *
+ *      Initialize shadow register mmio addresses, clear outstanding
+ *      interrupts on the port, and unmask interrupts for the future
+ *      start of the port.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_port_init(struct ata_ioports *port,  void __iomem *port_mmio)
 {
-        /* PIO related setup */
-        port->data_addr = base + SHD_PIO_DATA_OFS;
-        port->error_addr = port->feature_addr = base + SHD_FEA_ERR_OFS;
-        port->nsect_addr = base + SHD_SECT_CNT_OFS;
-        port->lbal_addr = base + SHD_LBA_L_OFS;
-        port->lbam_addr = base + SHD_LBA_M_OFS;
-        port->lbah_addr = base + SHD_LBA_H_OFS;
-        port->device_addr = base + SHD_DEV_HD_OFS;
-        port->status_addr = port->command_addr = base + SHD_CMD_STA_OFS;
-        port->altstatus_addr = port->ctl_addr = base + SHD_CTL_AST_OFS;
-        /* unused */
+        unsigned long shd_base = (unsigned long) port_mmio + SHD_BLK_OFS;
+        unsigned serr_ofs;
+
+        /* PIO related setup 
+         */
+        port->data_addr = shd_base + (sizeof(u32) * ATA_REG_DATA);
+        port->error_addr = 
+                port->feature_addr = shd_base + (sizeof(u32) * ATA_REG_ERR);
+        port->nsect_addr = shd_base + (sizeof(u32) * ATA_REG_NSECT);
+        port->lbal_addr = shd_base + (sizeof(u32) * ATA_REG_LBAL);
+        port->lbam_addr = shd_base + (sizeof(u32) * ATA_REG_LBAM);
+        port->lbah_addr = shd_base + (sizeof(u32) * ATA_REG_LBAH);
+        port->device_addr = shd_base + (sizeof(u32) * ATA_REG_DEVICE);
+        port->status_addr = 
+                port->command_addr = shd_base + (sizeof(u32) * ATA_REG_STATUS);
+        /* special case: control/altstatus doesn't have ATA_REG_ address */
+        port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST_OFS;
+
+        /* unused: */
         port->cmd_addr = port->bmdma_addr = port->scr_addr = 0;
 
+        /* Clear any currently outstanding port interrupt conditions */
+        serr_ofs = mv_scr_offset(SCR_ERROR);
+        writelfl(readl(port_mmio + serr_ofs), port_mmio + serr_ofs);
+        writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
+
         /* unmask all EDMA error interrupts */
-        writel(~0, (void __iomem *)base + EDMA_ERR_IRQ_MASK_OFS);
+        writelfl(~0, port_mmio + EDMA_ERR_IRQ_MASK_OFS);
 
         VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n", 
-                readl((void __iomem *)base + EDMA_CFG_OFS),
-                readl((void __iomem *)base + EDMA_ERR_IRQ_CAUSE_OFS),
-                readl((void __iomem *)base + EDMA_ERR_IRQ_MASK_OFS));
+                readl(port_mmio + EDMA_CFG_OFS),
+                readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS),
+                readl(port_mmio + EDMA_ERR_IRQ_MASK_OFS));
 }
 
+/**
+ *      mv_host_init - Perform some early initialization of the host.
+ *      @probe_ent: early data struct representing the host
+ *
+ *      If possible, do an early global reset of the host.  Then do
+ *      our port init and clear/unmask all/relevant host interrupts.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 static int mv_host_init(struct ata_probe_ent *probe_ent)
 {
         int rc = 0, n_hc, port, hc;
         void __iomem *mmio = probe_ent->mmio_base;
         void __iomem *port_mmio;
 
-        if (mv_master_reset(probe_ent->mmio_base)) {
+        if ((MV_FLAG_GLBL_SFT_RST & probe_ent->host_flags) && 
+            mv_global_soft_reset(probe_ent->mmio_base)) {
                 rc = 1;
                 goto done;
         }
@@ -676,17 +1392,27 @@ static int mv_host_init(struct ata_probe_ent *probe_ent)
 
         for (port = 0; port < probe_ent->n_ports; port++) {
                 port_mmio = mv_port_base(mmio, port);
-                mv_port_init(&probe_ent->port[port], (unsigned long)port_mmio);
+                mv_port_init(&probe_ent->port[port], port_mmio);
         }
 
         for (hc = 0; hc < n_hc; hc++) {
-                VPRINTK("HC%i: HC config=0x%08x HC IRQ cause=0x%08x\n", hc,
-                        readl(mv_hc_base(mmio, hc) + HC_CFG_OFS),
-                        readl(mv_hc_base(mmio, hc) + HC_IRQ_CAUSE_OFS));
+                void __iomem *hc_mmio = mv_hc_base(mmio, hc);
+
+                VPRINTK("HC%i: HC config=0x%08x HC IRQ cause "
+                        "(before clear)=0x%08x\n", hc,
+                        readl(hc_mmio + HC_CFG_OFS),
+                        readl(hc_mmio + HC_IRQ_CAUSE_OFS));
+
+                /* Clear any currently outstanding hc interrupt conditions */
+                writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
         }
 
-        writel(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
-        writel(PCI_UNMASK_ALL_IRQS, mmio + PCI_IRQ_MASK_OFS);
+        /* Clear any currently outstanding host interrupt conditions */
+        writelfl(0, mmio + PCI_IRQ_CAUSE_OFS);
+
+        /* and unmask interrupt generation for host regs */
+        writelfl(PCI_UNMASK_ALL_IRQS, mmio + PCI_IRQ_MASK_OFS);
+        writelfl(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
 
         VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
                 "PCI int cause/mask=0x%08x/0x%08x\n", 
@@ -694,11 +1420,53 @@ static int mv_host_init(struct ata_probe_ent *probe_ent)
                 readl(mmio + HC_MAIN_IRQ_MASK_OFS),
                 readl(mmio + PCI_IRQ_CAUSE_OFS),
                 readl(mmio + PCI_IRQ_MASK_OFS));
-
- done:
+done:
         return rc;
 }
 
+/**
+ *      mv_print_info - Dump key info to kernel log for perusal.
+ *      @probe_ent: early data struct representing the host
+ *
+ *      FIXME: complete this.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+static void mv_print_info(struct ata_probe_ent *probe_ent)
+{
+        struct pci_dev *pdev = to_pci_dev(probe_ent->dev);
+        struct mv_host_priv *hpriv = probe_ent->private_data;
+        u8 rev_id, scc;
+        const char *scc_s;
+
+        /* Use this to determine the HW stepping of the chip so we know
+         * what errata to workaround
+         */
+        pci_read_config_byte(pdev, PCI_REVISION_ID, &rev_id);
+
+        pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &scc);
+        if (scc == 0)
+                scc_s = "SCSI";
+        else if (scc == 0x01)
+                scc_s = "RAID";
+        else
+                scc_s = "unknown";
+
+        printk(KERN_INFO DRV_NAME 
+               "(%s) %u slots %u ports %s mode IRQ via %s\n",
+               pci_name(pdev), (unsigned)MV_MAX_Q_DEPTH, probe_ent->n_ports, 
+               scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
+}
+
+/**
+ *      mv_init_one - handle a positive probe of a Marvell host
+ *      @pdev: PCI device found
+ *      @ent: PCI device ID entry for the matched host
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version = 0;
@@ -706,16 +1474,12 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         struct mv_host_priv *hpriv;
         unsigned int board_idx = (unsigned int)ent->driver_data;
         void __iomem *mmio_base;
-        int pci_dev_busy = 0;
-        int rc;
+        int pci_dev_busy = 0, rc;
 
         if (!printed_version++) {
-                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+                printk(KERN_INFO DRV_NAME " version " DRV_VERSION "\n");
         }
 
-        VPRINTK("ENTER for PCI Bus:Slot.Func=%u:%u.%u\n", pdev->bus->number,
-                PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
-
         rc = pci_enable_device(pdev);
         if (rc) {
                 return rc;
@@ -727,8 +1491,6 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err_out;
         }
 
-        pci_intx(pdev, 1);
-
         probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
         if (probe_ent == NULL) {
                 rc = -ENOMEM;
@@ -739,8 +1501,7 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         probe_ent->dev = pci_dev_to_dev(pdev);
         INIT_LIST_HEAD(&probe_ent->node);
 
-        mmio_base = ioremap_nocache(pci_resource_start(pdev, MV_PRIMARY_BAR),
-                                    pci_resource_len(pdev, MV_PRIMARY_BAR));
+        mmio_base = pci_iomap(pdev, MV_PRIMARY_BAR, 0);
         if (mmio_base == NULL) {
                 rc = -ENOMEM;
                 goto err_out_free_ent;
@@ -769,37 +1530,40 @@ static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc) {
                 goto err_out_hpriv;
         }
-/*      mv_print_info(probe_ent); */
 
-        {
-                int b, w;
-                u32 dw[4];      /* hold a line of 16b */
-                VPRINTK("PCI config space:\n");
-                for (b = 0; b < 0x40; ) {
-                        for (w = 0; w < 4; w++) {
-                                (void) pci_read_config_dword(pdev,b,&dw[w]);
-                                b += sizeof(*dw);
-                        }
-                        VPRINTK("%08x %08x %08x %08x\n",
-                                dw[0],dw[1],dw[2],dw[3]);
-                }
+        /* Enable interrupts */
+        if (pci_enable_msi(pdev) == 0) {
+                hpriv->hp_flags |= MV_HP_FLAG_MSI;
+        } else {
+                pci_intx(pdev, 1);
         }
 
-        /* FIXME: check ata_device_add return value */
-        ata_device_add(probe_ent);
-        kfree(probe_ent);
+        mv_dump_pci_cfg(pdev, 0x68);
+        mv_print_info(probe_ent);
+
+        if (ata_device_add(probe_ent) == 0) {
+                rc = -ENODEV;           /* No devices discovered */
+                goto err_out_dev_add;
+        }
 
+        kfree(probe_ent);
         return 0;
 
- err_out_hpriv:
+err_out_dev_add:
+        if (MV_HP_FLAG_MSI & hpriv->hp_flags) {
+                pci_disable_msi(pdev);
+        } else {
+                pci_intx(pdev, 0);
+        }
+err_out_hpriv:
         kfree(hpriv);
- err_out_iounmap:
-        iounmap(mmio_base);
- err_out_free_ent:
+err_out_iounmap:
+        pci_iounmap(pdev, mmio_base);
+err_out_free_ent:
         kfree(probe_ent);
- err_out_regions:
+err_out_regions:
         pci_release_regions(pdev);
- err_out:
+err_out:
         if (!pci_dev_busy) {
                 pci_disable_device(pdev);
         }
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index c05653c7779d..9fa2535dd937 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -29,6 +29,8 @@
  *  NV-specific details such as register offsets, SATA phy location,
  *  hotplug info, etc.
  *
+ *  0.09
+ *     - Fixed bug introduced by 0.08's MCP51 and MCP55 support.
  *
  *  0.08
  *     - Added support for MCP51 and MCP55.
@@ -132,9 +134,7 @@ enum nv_host_type
         GENERIC,
         NFORCE2,
         NFORCE3,
-        CK804,
-        MCP51,
-        MCP55
+        CK804
 };
 
 static struct pci_device_id nv_pci_tbl[] = {
@@ -153,13 +153,13 @@ static struct pci_device_id nv_pci_tbl[] = {
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP51 },
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP51 },
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP55 },
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, MCP55 },
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
         { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
                 PCI_ANY_ID, PCI_ANY_ID,
                 PCI_CLASS_STORAGE_IDE<<8, 0xffff00, GENERIC },
@@ -405,7 +405,7 @@ static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         rc = -ENOMEM;
 
         ppi = &nv_port_info;
-        probe_ent = ata_pci_init_native_mode(pdev, &ppi);
+        probe_ent = ata_pci_init_native_mode(pdev, &ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
         if (!probe_ent)
                 goto err_out_regions;
 
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index 538ad727bd2e..def7e0d9dacb 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -438,11 +438,11 @@ static inline unsigned int pdc_host_intr( struct ata_port *ap,
                 break;
 
         default:
-                ap->stats.idle_irq++;
-                break;
+                ap->stats.idle_irq++;
+                break;
         }
 
-        return handled;
+        return handled;
 }
 
 static void pdc_irq_clear(struct ata_port *ap)
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
new file mode 100644
index 000000000000..19857814d69f
--- /dev/null
+++ b/drivers/scsi/sata_sil24.c
@@ -0,0 +1,875 @@
+/*
+ * sata_sil24.c - Driver for Silicon Image 3124/3132 SATA-2 controllers
+ *
+ * Copyright 2005  Tejun Heo
+ *
+ * Based on preview driver from Silicon Image.
+ *
+ * NOTE: No NCQ/ATAPI support yet.  The preview driver didn't support
+ * NCQ nor ATAPI, and, unfortunately, I couldn't find out how to make
+ * those work.  Enabling those shouldn't be difficult.  Basic
+ * structure is all there (in libata-dev tree).  If you have any
+ * information about this hardware, please contact me or linux-ide.
+ * Info is needed on...
+ *
+ * - How to issue tagged commands and turn on sactive on issue accordingly.
+ * - Where to put an ATAPI command and how to tell the device to send it.
+ * - How to enable/use 64bit.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <scsi/scsi_host.h>
+#include "scsi.h"
+#include <linux/libata.h>
+#include <asm/io.h>
+
+#define DRV_NAME        "sata_sil24"
+#define DRV_VERSION     "0.22"  /* Silicon Image's preview driver was 0.10 */
+
+/*
+ * Port request block (PRB) 32 bytes
+ */
+struct sil24_prb {
+        u16     ctrl;
+        u16     prot;
+        u32     rx_cnt;
+        u8      fis[6 * 4];
+};
+
+/*
+ * Scatter gather entry (SGE) 16 bytes
+ */
+struct sil24_sge {
+        u64     addr;
+        u32     cnt;
+        u32     flags;
+};
+
+/*
+ * Port multiplier
+ */
+struct sil24_port_multiplier {
+        u32     diag;
+        u32     sactive;
+};
+
+enum {
+        /*
+         * Global controller registers (128 bytes @ BAR0)
+         */
+                /* 32 bit regs */
+        HOST_SLOT_STAT          = 0x00, /* 32 bit slot stat * 4 */
+        HOST_CTRL               = 0x40,
+        HOST_IRQ_STAT           = 0x44,
+        HOST_PHY_CFG            = 0x48,
+        HOST_BIST_CTRL          = 0x50,
+        HOST_BIST_PTRN          = 0x54,
+        HOST_BIST_STAT          = 0x58,
+        HOST_MEM_BIST_STAT      = 0x5c,
+        HOST_FLASH_CMD          = 0x70,
+                /* 8 bit regs */
+        HOST_FLASH_DATA         = 0x74,
+        HOST_TRANSITION_DETECT  = 0x75,
+        HOST_GPIO_CTRL          = 0x76,
+        HOST_I2C_ADDR           = 0x78, /* 32 bit */
+        HOST_I2C_DATA           = 0x7c,
+        HOST_I2C_XFER_CNT       = 0x7e,
+        HOST_I2C_CTRL           = 0x7f,
+
+        /* HOST_SLOT_STAT bits */
+        HOST_SSTAT_ATTN         = (1 << 31),
+
+        /*
+         * Port registers
+         * (8192 bytes @ +0x0000, +0x2000, +0x4000 and +0x6000 @ BAR2)
+         */
+        PORT_REGS_SIZE          = 0x2000,
+        PORT_PRB                = 0x0000, /* (32 bytes PRB + 16 bytes SGEs * 6) * 31 (3968 bytes) */
+
+        PORT_PM                 = 0x0f80, /* 8 bytes PM * 16 (128 bytes) */
+                /* 32 bit regs */
+        PORT_CTRL_STAT          = 0x1000, /* write: ctrl-set, read: stat */
+        PORT_CTRL_CLR           = 0x1004, /* write: ctrl-clear */
+        PORT_IRQ_STAT           = 0x1008, /* high: status, low: interrupt */
+        PORT_IRQ_ENABLE_SET     = 0x1010, /* write: enable-set */
+        PORT_IRQ_ENABLE_CLR     = 0x1014, /* write: enable-clear */
+        PORT_ACTIVATE_UPPER_ADDR= 0x101c,
+        PORT_EXEC_FIFO          = 0x1020, /* command execution fifo */
+        PORT_CMD_ERR            = 0x1024, /* command error number */
+        PORT_FIS_CFG            = 0x1028,
+        PORT_FIFO_THRES         = 0x102c,
+                /* 16 bit regs */
+        PORT_DECODE_ERR_CNT     = 0x1040,
+        PORT_DECODE_ERR_THRESH  = 0x1042,
+        PORT_CRC_ERR_CNT        = 0x1044,
+        PORT_CRC_ERR_THRESH     = 0x1046,
+        PORT_HSHK_ERR_CNT       = 0x1048,
+        PORT_HSHK_ERR_THRESH    = 0x104a,
+                /* 32 bit regs */
+        PORT_PHY_CFG            = 0x1050,
+        PORT_SLOT_STAT          = 0x1800,
+        PORT_CMD_ACTIVATE       = 0x1c00, /* 64 bit cmd activate * 31 (248 bytes) */
+        PORT_EXEC_DIAG          = 0x1e00, /* 32bit exec diag * 16 (64 bytes, 0-10 used on 3124) */
+        PORT_PSD_DIAG           = 0x1e40, /* 32bit psd diag * 16 (64 bytes, 0-8 used on 3124) */
+        PORT_SCONTROL           = 0x1f00,
+        PORT_SSTATUS            = 0x1f04,
+        PORT_SERROR             = 0x1f08,
+        PORT_SACTIVE            = 0x1f0c,
+
+        /* PORT_CTRL_STAT bits */
+        PORT_CS_PORT_RST        = (1 << 0), /* port reset */
+        PORT_CS_DEV_RST         = (1 << 1), /* device reset */
+        PORT_CS_INIT            = (1 << 2), /* port initialize */
+        PORT_CS_IRQ_WOC         = (1 << 3), /* interrupt write one to clear */
+        PORT_CS_RESUME          = (1 << 6), /* port resume */
+        PORT_CS_32BIT_ACTV      = (1 << 10), /* 32-bit activation */
+        PORT_CS_PM_EN           = (1 << 13), /* port multiplier enable */
+        PORT_CS_RDY             = (1 << 31), /* port ready to accept commands */
+
+        /* PORT_IRQ_STAT/ENABLE_SET/CLR */
+        /* bits[11:0] are masked */
+        PORT_IRQ_COMPLETE       = (1 << 0), /* command(s) completed */
+        PORT_IRQ_ERROR          = (1 << 1), /* command execution error */
+        PORT_IRQ_PORTRDY_CHG    = (1 << 2), /* port ready change */
+        PORT_IRQ_PWR_CHG        = (1 << 3), /* power management change */
+        PORT_IRQ_PHYRDY_CHG     = (1 << 4), /* PHY ready change */
+        PORT_IRQ_COMWAKE        = (1 << 5), /* COMWAKE received */
+        PORT_IRQ_UNK_FIS        = (1 << 6), /* Unknown FIS received */
+        PORT_IRQ_SDB_FIS        = (1 << 11), /* SDB FIS received */
+
+        /* bits[27:16] are unmasked (raw) */
+        PORT_IRQ_RAW_SHIFT      = 16,
+        PORT_IRQ_MASKED_MASK    = 0x7ff,
+        PORT_IRQ_RAW_MASK       = (0x7ff << PORT_IRQ_RAW_SHIFT),
+
+        /* ENABLE_SET/CLR specific, intr steering - 2 bit field */
+        PORT_IRQ_STEER_SHIFT    = 30,
+        PORT_IRQ_STEER_MASK     = (3 << PORT_IRQ_STEER_SHIFT),
+
+        /* PORT_CMD_ERR constants */
+        PORT_CERR_DEV           = 1, /* Error bit in D2H Register FIS */
+        PORT_CERR_SDB           = 2, /* Error bit in SDB FIS */
+        PORT_CERR_DATA          = 3, /* Error in data FIS not detected by dev */
+        PORT_CERR_SEND          = 4, /* Initial cmd FIS transmission failure */
+        PORT_CERR_INCONSISTENT  = 5, /* Protocol mismatch */
+        PORT_CERR_DIRECTION     = 6, /* Data direction mismatch */
+        PORT_CERR_UNDERRUN      = 7, /* Ran out of SGEs while writing */
+        PORT_CERR_OVERRUN       = 8, /* Ran out of SGEs while reading */
+        PORT_CERR_PKT_PROT      = 11, /* DIR invalid in 1st PIO setup of ATAPI */
+        PORT_CERR_SGT_BOUNDARY  = 16, /* PLD ecode 00 - SGT not on qword boundary */
+        PORT_CERR_SGT_TGTABRT   = 17, /* PLD ecode 01 - target abort */
+        PORT_CERR_SGT_MSTABRT   = 18, /* PLD ecode 10 - master abort */
+        PORT_CERR_SGT_PCIPERR   = 19, /* PLD ecode 11 - PCI parity err while fetching SGT */
+        PORT_CERR_CMD_BOUNDARY  = 24, /* ctrl[15:13] 001 - PRB not on qword boundary */
+        PORT_CERR_CMD_TGTABRT   = 25, /* ctrl[15:13] 010 - target abort */
+        PORT_CERR_CMD_MSTABRT   = 26, /* ctrl[15:13] 100 - master abort */
+        PORT_CERR_CMD_PCIPERR   = 27, /* ctrl[15:13] 110 - PCI parity err while fetching PRB */
+        PORT_CERR_XFR_UNDEF     = 32, /* PSD ecode 00 - undefined */
+        PORT_CERR_XFR_TGTABRT   = 33, /* PSD ecode 01 - target abort */
+        PORT_CERR_XFR_MSGABRT   = 34, /* PSD ecode 10 - master abort */
+        PORT_CERR_XFR_PCIPERR   = 35, /* PSD ecode 11 - PCI prity err during transfer */
+        PORT_CERR_SENDSERVICE   = 36, /* FIS received while sending service */
+
+        /*
+         * Other constants
+         */
+        SGE_TRM                 = (1 << 31), /* Last SGE in chain */
+        PRB_SOFT_RST            = (1 << 7),  /* Soft reset request (ign BSY?) */
+
+        /* board id */
+        BID_SIL3124             = 0,
+        BID_SIL3132             = 1,
+        BID_SIL3131             = 2,
+
+        IRQ_STAT_4PORTS         = 0xf,
+};
+
+struct sil24_cmd_block {
+        struct sil24_prb prb;
+        struct sil24_sge sge[LIBATA_MAX_PRD];
+};
+
+/*
+ * ap->private_data
+ *
+ * The preview driver always returned 0 for status.  We emulate it
+ * here from the previous interrupt.
+ */
+struct sil24_port_priv {
+        struct sil24_cmd_block *cmd_block;      /* 32 cmd blocks */
+        dma_addr_t cmd_block_dma;               /* DMA base addr for them */
+        struct ata_taskfile tf;                 /* Cached taskfile registers */
+};
+
+/* ap->host_set->private_data */
+struct sil24_host_priv {
+        void *host_base;        /* global controller control (128 bytes @BAR0) */
+        void *port_base;        /* port registers (4 * 8192 bytes @BAR2) */
+};
+
+static u8 sil24_check_status(struct ata_port *ap);
+static u8 sil24_check_err(struct ata_port *ap);
+static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg);
+static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
+static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
+static void sil24_phy_reset(struct ata_port *ap);
+static void sil24_qc_prep(struct ata_queued_cmd *qc);
+static int sil24_qc_issue(struct ata_queued_cmd *qc);
+static void sil24_irq_clear(struct ata_port *ap);
+static void sil24_eng_timeout(struct ata_port *ap);
+static irqreturn_t sil24_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
+static int sil24_port_start(struct ata_port *ap);
+static void sil24_port_stop(struct ata_port *ap);
+static void sil24_host_stop(struct ata_host_set *host_set);
+static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
+
+static struct pci_device_id sil24_pci_tbl[] = {
+        { 0x1095, 0x3124, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3124 },
+        { 0x1095, 0x3132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3132 },
+        { 0x1095, 0x3131, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3131 },
+        { 0x1095, 0x3531, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3131 },
+        { } /* terminate list */
+};
+
+static struct pci_driver sil24_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = sil24_pci_tbl,
+        .probe                  = sil24_init_one,
+        .remove                 = ata_pci_remove_one, /* safe? */
+};
+
+static Scsi_Host_Template sil24_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .eh_strategy_handler    = ata_scsi_error,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .max_sectors            = ATA_MAX_SECTORS,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .bios_param             = ata_std_bios_param,
+        .ordered_flush          = 1, /* NCQ not supported yet */
+};
+
+static struct ata_port_operations sil24_ops = {
+        .port_disable           = ata_port_disable,
+
+        .check_status           = sil24_check_status,
+        .check_altstatus        = sil24_check_status,
+        .check_err              = sil24_check_err,
+        .dev_select             = ata_noop_dev_select,
+
+        .tf_read                = sil24_tf_read,
+
+        .phy_reset              = sil24_phy_reset,
+
+        .qc_prep                = sil24_qc_prep,
+        .qc_issue               = sil24_qc_issue,
+
+        .eng_timeout            = sil24_eng_timeout,
+
+        .irq_handler            = sil24_interrupt,
+        .irq_clear              = sil24_irq_clear,
+
+        .scr_read               = sil24_scr_read,
+        .scr_write              = sil24_scr_write,
+
+        .port_start             = sil24_port_start,
+        .port_stop              = sil24_port_stop,
+        .host_stop              = sil24_host_stop,
+};
+
+/*
+ * Use bits 30-31 of host_flags to encode available port numbers.
+ * Current maxium is 4.
+ */
+#define SIL24_NPORTS2FLAG(nports)       ((((unsigned)(nports) - 1) & 0x3) << 30)
+#define SIL24_FLAG2NPORTS(flag)         ((((flag) >> 30) & 0x3) + 1)
+
+static struct ata_port_info sil24_port_info[] = {
+        /* sil_3124 */
+        {
+                .sht            = &sil24_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
+                                  ATA_FLAG_PIO_DMA | SIL24_NPORTS2FLAG(4),
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil24_ops,
+        },
+        /* sil_3132 */ 
+        {
+                .sht            = &sil24_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
+                                  ATA_FLAG_PIO_DMA | SIL24_NPORTS2FLAG(2),
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil24_ops,
+        },
+        /* sil_3131/sil_3531 */
+        {
+                .sht            = &sil24_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
+                                  ATA_FLAG_PIO_DMA | SIL24_NPORTS2FLAG(1),
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil24_ops,
+        },
+};
+
+static inline void sil24_update_tf(struct ata_port *ap)
+{
+        struct sil24_port_priv *pp = ap->private_data;
+        void *port = (void *)ap->ioaddr.cmd_addr;
+        struct sil24_prb *prb = port;
+
+        ata_tf_from_fis(prb->fis, &pp->tf);
+}
+
+static u8 sil24_check_status(struct ata_port *ap)
+{
+        struct sil24_port_priv *pp = ap->private_data;
+        return pp->tf.command;
+}
+
+static u8 sil24_check_err(struct ata_port *ap)
+{
+        struct sil24_port_priv *pp = ap->private_data;
+        return pp->tf.feature;
+}
+
+static int sil24_scr_map[] = {
+        [SCR_CONTROL]   = 0,
+        [SCR_STATUS]    = 1,
+        [SCR_ERROR]     = 2,
+        [SCR_ACTIVE]    = 3,
+};
+
+static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg)
+{
+        void *scr_addr = (void *)ap->ioaddr.scr_addr;
+        if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
+                void *addr;
+                addr = scr_addr + sil24_scr_map[sc_reg] * 4;
+                return readl(scr_addr + sil24_scr_map[sc_reg] * 4);
+        }
+        return 0xffffffffU;
+}
+
+static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
+{
+        void *scr_addr = (void *)ap->ioaddr.scr_addr;
+        if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
+                void *addr;
+                addr = scr_addr + sil24_scr_map[sc_reg] * 4;
+                writel(val, scr_addr + sil24_scr_map[sc_reg] * 4);
+        }
+}
+
+static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        struct sil24_port_priv *pp = ap->private_data;
+        *tf = pp->tf;
+}
+
+static void sil24_phy_reset(struct ata_port *ap)
+{
+        __sata_phy_reset(ap);
+        /*
+         * No ATAPI yet.  Just unconditionally indicate ATA device.
+         * If ATAPI device is attached, it will fail ATA_CMD_ID_ATA
+         * and libata core will ignore the device.
+         */
+        if (!(ap->flags & ATA_FLAG_PORT_DISABLED))
+                ap->device[0].class = ATA_DEV_ATA;
+}
+
+static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
+                                 struct sil24_cmd_block *cb)
+{
+        struct scatterlist *sg = qc->sg;
+        struct sil24_sge *sge = cb->sge;
+        unsigned i;
+
+        for (i = 0; i < qc->n_elem; i++, sg++, sge++) {
+                sge->addr = cpu_to_le64(sg_dma_address(sg));
+                sge->cnt = cpu_to_le32(sg_dma_len(sg));
+                sge->flags = 0;
+                sge->flags = i < qc->n_elem - 1 ? 0 : cpu_to_le32(SGE_TRM);
+        }
+}
+
+static void sil24_qc_prep(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct sil24_port_priv *pp = ap->private_data;
+        struct sil24_cmd_block *cb = pp->cmd_block + qc->tag;
+        struct sil24_prb *prb = &cb->prb;
+
+        switch (qc->tf.protocol) {
+        case ATA_PROT_PIO:
+        case ATA_PROT_DMA:
+        case ATA_PROT_NODATA:
+                break;
+        default:
+                /* ATAPI isn't supported yet */
+                BUG();
+        }
+
+        ata_tf_to_fis(&qc->tf, prb->fis, 0);
+
+        if (qc->flags & ATA_QCFLAG_DMAMAP)
+                sil24_fill_sg(qc, cb);
+}
+
+static int sil24_qc_issue(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void *port = (void *)ap->ioaddr.cmd_addr;
+        struct sil24_port_priv *pp = ap->private_data;
+        dma_addr_t paddr = pp->cmd_block_dma + qc->tag * sizeof(*pp->cmd_block);
+
+        writel((u32)paddr, port + PORT_CMD_ACTIVATE);
+        return 0;
+}
+
+static void sil24_irq_clear(struct ata_port *ap)
+{
+        /* unused */
+}
+
+static int __sil24_reset_controller(void *port)
+{
+        int cnt;
+        u32 tmp;
+
+        /* Reset controller state.  Is this correct? */
+        writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
+        readl(port + PORT_CTRL_STAT);   /* sync */
+
+        /* Max ~100ms */
+        for (cnt = 0; cnt < 1000; cnt++) {
+                udelay(100);
+                tmp = readl(port + PORT_CTRL_STAT);
+                if (!(tmp & PORT_CS_DEV_RST))
+                        break;
+        }
+
+        if (tmp & PORT_CS_DEV_RST)
+                return -1;
+        return 0;
+}
+
+static void sil24_reset_controller(struct ata_port *ap)
+{
+        printk(KERN_NOTICE DRV_NAME
+               " ata%u: resetting controller...\n", ap->id);
+        if (__sil24_reset_controller((void *)ap->ioaddr.cmd_addr))
+                printk(KERN_ERR DRV_NAME
+                       " ata%u: failed to reset controller\n", ap->id);
+}
+
+static void sil24_eng_timeout(struct ata_port *ap)
+{
+        struct ata_queued_cmd *qc;
+
+        qc = ata_qc_from_tag(ap, ap->active_tag);
+        if (!qc) {
+                printk(KERN_ERR "ata%u: BUG: tiemout without command\n",
+                       ap->id);
+                return;
+        }
+
+        /*
+         * hack alert!  We cannot use the supplied completion
+         * function from inside the ->eh_strategy_handler() thread.
+         * libata is the only user of ->eh_strategy_handler() in
+         * any kernel, so the default scsi_done() assumes it is
+         * not being called from the SCSI EH.
+         */
+        printk(KERN_ERR "ata%u: command timeout\n", ap->id);
+        qc->scsidone = scsi_finish_command;
+        ata_qc_complete(qc, ATA_ERR);
+
+        sil24_reset_controller(ap);
+}
+
+static void sil24_error_intr(struct ata_port *ap, u32 slot_stat)
+{
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct sil24_port_priv *pp = ap->private_data;
+        void *port = (void *)ap->ioaddr.cmd_addr;
+        u32 irq_stat, cmd_err, sstatus, serror;
+
+        irq_stat = readl(port + PORT_IRQ_STAT);
+        writel(irq_stat, port + PORT_IRQ_STAT);         /* clear irq */
+
+        if (!(irq_stat & PORT_IRQ_ERROR)) {
+                /* ignore non-completion, non-error irqs for now */
+                printk(KERN_WARNING DRV_NAME
+                       "ata%u: non-error exception irq (irq_stat %x)\n",
+                       ap->id, irq_stat);
+                return;
+        }
+
+        cmd_err = readl(port + PORT_CMD_ERR);
+        sstatus = readl(port + PORT_SSTATUS);
+        serror = readl(port + PORT_SERROR);
+        if (serror)
+                writel(serror, port + PORT_SERROR);
+
+        printk(KERN_ERR DRV_NAME " ata%u: error interrupt on port%d\n"
+               "  stat=0x%x irq=0x%x cmd_err=%d sstatus=0x%x serror=0x%x\n",
+               ap->id, ap->port_no, slot_stat, irq_stat, cmd_err, sstatus, serror);
+
+        if (cmd_err == PORT_CERR_DEV || cmd_err == PORT_CERR_SDB) {
+                /*
+                 * Device is reporting error, tf registers are valid.
+                 */
+                sil24_update_tf(ap);
+        } else {
+                /*
+                 * Other errors.  libata currently doesn't have any
+                 * mechanism to report these errors.  Just turn on
+                 * ATA_ERR.
+                 */
+                pp->tf.command = ATA_ERR;
+        }
+
+        if (qc)
+                ata_qc_complete(qc, pp->tf.command);
+
+        sil24_reset_controller(ap);
+}
+
+static inline void sil24_host_intr(struct ata_port *ap)
+{
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        void *port = (void *)ap->ioaddr.cmd_addr;
+        u32 slot_stat;
+
+        slot_stat = readl(port + PORT_SLOT_STAT);
+        if (!(slot_stat & HOST_SSTAT_ATTN)) {
+                struct sil24_port_priv *pp = ap->private_data;
+                /*
+                 * !HOST_SSAT_ATTN guarantees successful completion,
+                 * so reading back tf registers is unnecessary for
+                 * most commands.  TODO: read tf registers for
+                 * commands which require these values on successful
+                 * completion (EXECUTE DEVICE DIAGNOSTIC, CHECK POWER,
+                 * DEVICE RESET and READ PORT MULTIPLIER (any more?).
+                 */
+                sil24_update_tf(ap);
+
+                if (qc)
+                        ata_qc_complete(qc, pp->tf.command);
+        } else
+                sil24_error_intr(ap, slot_stat);
+}
+
+static irqreturn_t sil24_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
+{
+        struct ata_host_set *host_set = dev_instance;
+        struct sil24_host_priv *hpriv = host_set->private_data;
+        unsigned handled = 0;
+        u32 status;
+        int i;
+
+        status = readl(hpriv->host_base + HOST_IRQ_STAT);
+
+        if (status == 0xffffffff) {
+                printk(KERN_ERR DRV_NAME ": IRQ status == 0xffffffff, "
+                       "PCI fault or device removal?\n");
+                goto out;
+        }
+
+        if (!(status & IRQ_STAT_4PORTS))
+                goto out;
+
+        spin_lock(&host_set->lock);
+
+        for (i = 0; i < host_set->n_ports; i++)
+                if (status & (1 << i)) {
+                        struct ata_port *ap = host_set->ports[i];
+                        if (ap && !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
+                                sil24_host_intr(host_set->ports[i]);
+                                handled++;
+                        } else
+                                printk(KERN_ERR DRV_NAME
+                                       ": interrupt from disabled port %d\n", i);
+                }
+
+        spin_unlock(&host_set->lock);
+ out:
+        return IRQ_RETVAL(handled);
+}
+
+static int sil24_port_start(struct ata_port *ap)
+{
+        struct device *dev = ap->host_set->dev;
+        struct sil24_port_priv *pp;
+        struct sil24_cmd_block *cb;
+        size_t cb_size = sizeof(*cb);
+        dma_addr_t cb_dma;
+
+        pp = kmalloc(sizeof(*pp), GFP_KERNEL);
+        if (!pp)
+                return -ENOMEM;
+        memset(pp, 0, sizeof(*pp));
+
+        pp->tf.command = ATA_DRDY;
+
+        cb = dma_alloc_coherent(dev, cb_size, &cb_dma, GFP_KERNEL);
+        if (!cb) {
+                kfree(pp);
+                return -ENOMEM;
+        }
+        memset(cb, 0, cb_size);
+
+        pp->cmd_block = cb;
+        pp->cmd_block_dma = cb_dma;
+
+        ap->private_data = pp;
+
+        return 0;
+}
+
+static void sil24_port_stop(struct ata_port *ap)
+{
+        struct device *dev = ap->host_set->dev;
+        struct sil24_port_priv *pp = ap->private_data;
+        size_t cb_size = sizeof(*pp->cmd_block);
+
+        dma_free_coherent(dev, cb_size, pp->cmd_block, pp->cmd_block_dma);
+        kfree(pp);
+}
+
+static void sil24_host_stop(struct ata_host_set *host_set)
+{
+        struct sil24_host_priv *hpriv = host_set->private_data;
+
+        iounmap(hpriv->host_base);
+        iounmap(hpriv->port_base);
+        kfree(hpriv);
+}
+
+static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        static int printed_version = 0;
+        unsigned int board_id = (unsigned int)ent->driver_data;
+        struct ata_port_info *pinfo = &sil24_port_info[board_id];
+        struct ata_probe_ent *probe_ent = NULL;
+        struct sil24_host_priv *hpriv = NULL;
+        void *host_base = NULL, *port_base = NULL;
+        int i, rc;
+
+        if (!printed_version++)
+                printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
+
+        rc = pci_enable_device(pdev);
+        if (rc)
+                return rc;
+
+        rc = pci_request_regions(pdev, DRV_NAME);
+        if (rc)
+                goto out_disable;
+
+        rc = -ENOMEM;
+        /* ioremap mmio registers */
+        host_base = ioremap(pci_resource_start(pdev, 0),
+                            pci_resource_len(pdev, 0));
+        if (!host_base)
+                goto out_free;
+        port_base = ioremap(pci_resource_start(pdev, 2),
+                            pci_resource_len(pdev, 2));
+        if (!port_base)
+                goto out_free;
+
+        /* allocate & init probe_ent and hpriv */
+        probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
+        if (!probe_ent)
+                goto out_free;
+
+        hpriv = kmalloc(sizeof(*hpriv), GFP_KERNEL);
+        if (!hpriv)
+                goto out_free;
+
+        memset(probe_ent, 0, sizeof(*probe_ent));
+        probe_ent->dev = pci_dev_to_dev(pdev);
+        INIT_LIST_HEAD(&probe_ent->node);
+
+        probe_ent->sht          = pinfo->sht;
+        probe_ent->host_flags   = pinfo->host_flags;
+        probe_ent->pio_mask     = pinfo->pio_mask;
+        probe_ent->udma_mask    = pinfo->udma_mask;
+        probe_ent->port_ops     = pinfo->port_ops;
+        probe_ent->n_ports      = SIL24_FLAG2NPORTS(pinfo->host_flags);
+
+        probe_ent->irq = pdev->irq;
+        probe_ent->irq_flags = SA_SHIRQ;
+        probe_ent->mmio_base = port_base;
+        probe_ent->private_data = hpriv;
+
+        memset(hpriv, 0, sizeof(*hpriv));
+        hpriv->host_base = host_base;
+        hpriv->port_base = port_base;
+
+        /*
+         * Configure the device
+         */
+        /*
+         * FIXME: This device is certainly 64-bit capable.  We just
+         * don't know how to use it.  After fixing 32bit activation in
+         * this function, enable 64bit masks here.
+         */
+        rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+        if (rc) {
+                printk(KERN_ERR DRV_NAME "(%s): 32-bit DMA enable failed\n",
+                       pci_name(pdev));
+                goto out_free;
+        }
+        rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+        if (rc) {
+                printk(KERN_ERR DRV_NAME "(%s): 32-bit consistent DMA enable failed\n",
+                       pci_name(pdev));
+                goto out_free;
+        }
+
+        /* GPIO off */
+        writel(0, host_base + HOST_FLASH_CMD);
+
+        /* Mask interrupts during initialization */
+        writel(0, host_base + HOST_CTRL);
+
+        for (i = 0; i < probe_ent->n_ports; i++) {
+                void *port = port_base + i * PORT_REGS_SIZE;
+                unsigned long portu = (unsigned long)port;
+                u32 tmp;
+                int cnt;
+
+                probe_ent->port[i].cmd_addr = portu + PORT_PRB;
+                probe_ent->port[i].scr_addr = portu + PORT_SCONTROL;
+
+                ata_std_ports(&probe_ent->port[i]);
+
+                /* Initial PHY setting */
+                writel(0x20c, port + PORT_PHY_CFG);
+
+                /* Clear port RST */
+                tmp = readl(port + PORT_CTRL_STAT);
+                if (tmp & PORT_CS_PORT_RST) {
+                        writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
+                        readl(port + PORT_CTRL_STAT);   /* sync */
+                        for (cnt = 0; cnt < 10; cnt++) {
+                                msleep(10);
+                                tmp = readl(port + PORT_CTRL_STAT);
+                                if (!(tmp & PORT_CS_PORT_RST))
+                                        break;
+                        }
+                        if (tmp & PORT_CS_PORT_RST)
+                                printk(KERN_ERR DRV_NAME
+                                       "(%s): failed to clear port RST\n",
+                                       pci_name(pdev));
+                }
+
+                /* Zero error counters. */
+                writel(0x8000, port + PORT_DECODE_ERR_THRESH);
+                writel(0x8000, port + PORT_CRC_ERR_THRESH);
+                writel(0x8000, port + PORT_HSHK_ERR_THRESH);
+                writel(0x0000, port + PORT_DECODE_ERR_CNT);
+                writel(0x0000, port + PORT_CRC_ERR_CNT);
+                writel(0x0000, port + PORT_HSHK_ERR_CNT);
+
+                /* FIXME: 32bit activation? */
+                writel(0, port + PORT_ACTIVATE_UPPER_ADDR);
+                writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_STAT);
+
+                /* Configure interrupts */
+                writel(0xffff, port + PORT_IRQ_ENABLE_CLR);
+                writel(PORT_IRQ_COMPLETE | PORT_IRQ_ERROR | PORT_IRQ_SDB_FIS,
+                       port + PORT_IRQ_ENABLE_SET);
+
+                /* Clear interrupts */
+                writel(0x0fff0fff, port + PORT_IRQ_STAT);
+                writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
+
+                /* Clear port multiplier enable and resume bits */
+                writel(PORT_CS_PM_EN | PORT_CS_RESUME, port + PORT_CTRL_CLR);
+
+                /* Reset itself */
+                if (__sil24_reset_controller(port))
+                        printk(KERN_ERR DRV_NAME
+                               "(%s): failed to reset controller\n",
+                               pci_name(pdev));
+        }
+
+        /* Turn on interrupts */
+        writel(IRQ_STAT_4PORTS, host_base + HOST_CTRL);
+
+        pci_set_master(pdev);
+
+        /* FIXME: check ata_device_add return value */
+        ata_device_add(probe_ent);
+
+        kfree(probe_ent);
+        return 0;
+
+ out_free:
+        if (host_base)
+                iounmap(host_base);
+        if (port_base)
+                iounmap(port_base);
+        kfree(probe_ent);
+        kfree(hpriv);
+        pci_release_regions(pdev);
+ out_disable:
+        pci_disable_device(pdev);
+        return rc;
+}
+
+static int __init sil24_init(void)
+{
+        return pci_module_init(&sil24_pci_driver);
+}
+
+static void __exit sil24_exit(void)
+{
+        pci_unregister_driver(&sil24_pci_driver);
+}
+
+MODULE_AUTHOR("Tejun Heo");
+MODULE_DESCRIPTION("Silicon Image 3124/3132 SATA low-level driver");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, sil24_pci_tbl);
+
+module_init(sil24_init);
+module_exit(sil24_exit);
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index b227e51d12f4..0761a3234fcf 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -263,7 +263,7 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err_out_regions;
 
         ppi = &sis_port_info;
-        probe_ent = ata_pci_init_native_mode(pdev, &ppi);
+        probe_ent = ata_pci_init_native_mode(pdev, &ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
         if (!probe_ent) {
                 rc = -ENOMEM;
                 goto err_out_regions;
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index 4c9fb8b71be1..9c06f2abe7f7 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -202,7 +202,7 @@ static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err_out_regions;
 
         ppi = &uli_port_info;
-        probe_ent = ata_pci_init_native_mode(pdev, &ppi);
+        probe_ent = ata_pci_init_native_mode(pdev, &ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
         if (!probe_ent) {
                 rc = -ENOMEM;
                 goto err_out_regions;
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index 128b996b07b7..565872479b9a 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -212,7 +212,7 @@ static struct ata_probe_ent *vt6420_init_probe_ent(struct pci_dev *pdev)
         struct ata_probe_ent *probe_ent;
         struct ata_port_info *ppi = &svia_port_info;
 
-        probe_ent = ata_pci_init_native_mode(pdev, &ppi);
+        probe_ent = ata_pci_init_native_mode(pdev, &ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
         if (!probe_ent)
                 return NULL;
 
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 5959e6755a81..656c0e8d160e 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -518,11 +518,7 @@ static void sunsu_change_mouse_baud(struct uart_sunsu_port *up)
 
         quot = up->port.uartclk / (16 * new_baud);
 
-        spin_unlock(&up->port.lock);
-
         sunsu_change_speed(&up->port, up->cflag, 0, quot);
-
-        spin_lock(&up->port.lock);
 }
 
 static void receive_kbd_ms_chars(struct uart_sunsu_port *up, struct pt_regs *regs, int is_break)