[SCSI] aic94xx: new driver

This is the end point of the separate aic94xx driver based on the
original driver and transport class from Luben Tuikov
<ltuikov@yahoo.com>

The log of the separate development is:

Alexis Bruemmer:
  o aic94xx: fix hotplug/unplug for expanderless systems
  o aic94xx: disable split completion timer/setting by default
  o aic94xx: wide port off expander support
  o aic94xx: remove various inline functions
  o aic94xx: use bitops
  o aic94xx: remove queue comment
  o aic94xx: remove sas_common.c
  o aic94xx: sas remove depot's
  o aic94xx: use available list_for_each_entry_safe_reverse()
  o aic94xx: sas header file merge

James Bottomley:
  o aic94xx: fix TF_TMF_NO_CTX processing
  o aic94xx: convert to request_firmware interface
  o aic94xx: fix hotplug/unplug
  o aic94xx: add link error counts to the expander phys
  o aic94xx: add transport class phy reset capability
  o aic94xx: remove local_attached flag
  o Remove README
  o Fixup Makefile variable for libsas rename
  o Rename sas->libsas
  o aic94xx: correct return code for sas_discover_event
  o aic94xx: use parent backlink port
  o aic94xx: remove channel abstraction
  o aic94xx: fix routing algorithms
  o aic94xx: add backlink port
  o aic94xx: fix cascaded expander properties
  o aic94xx: fix sleep under lock
  o aic94xx: fix panic on module removal in complex topology
  o aic94xx: make use of the new sas_port
  o rename sas_port to asd_sas_port
  o Fix for eh_strategy_handler move
  o aic94xx: move entirely over to correct transport class formulation
  o remove last vestages of sas_rphy_alloc()
  o update for eh_timed_out move
  o Preliminary expander support for aic94xx
  o sas: remove event thread
  o minor warning cleanups
  o remove last vestiges of id mapping arrays
  o Further updates
  o Convert aic94xx over entirely to the transport class end device and
  o update aic94xx/sas to use the new sas transport class end device
  o [PATCH] aic94xx: attaching to the sas transport class
  o Add missing completion removal from prior patch
  o [PATCH] aic94xx: attaching to the sas transport class
  o Build fixes from akpm

Jeff Garzik:
  o [scsi aic94xx] Remove ->owner from PCI info table

Luben Tuikov:
  o initial aic94xx driver

Mike Anderson:
  o aic94xx: fix panic on module insertion
  o aic94xx: stub out SATA_DEV case
  o aic94xx: compile warning cleanups
  o aic94xx: sas_alloc_task
  o aic94xx: ref count update
  o aic94xx nexus loss time value
  o [PATCH] aic94xx: driver assertion in non-x86 BIOS env

Randy Dunlap:
  o libsas: externs not needed

Robert Tarte:
  o aic94xx: sequence patch - fixes SATA support

Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

1 files changed, 786 insertions, 0 deletions

diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
new file mode 100644
index 000000000000..43e0e4e36934
--- /dev/null
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -0,0 +1,786 @@
+/*
+ * Serial Attached SCSI (SAS) class SCSI Host glue.
+ *
+ * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
+ * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
+ *
+ * This file is licensed under GPLv2.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ *
+ */
+
+#include "sas_internal.h"
+
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_tcq.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_transport.h>
+#include <scsi/scsi_transport_sas.h>
+#include "../scsi_sas_internal.h"
+
+#include <linux/err.h>
+#include <linux/blkdev.h>
+#include <linux/scatterlist.h>
+
+/* ---------- SCSI Host glue ---------- */
+
+#define TO_SAS_TASK(_scsi_cmd)  ((void *)(_scsi_cmd)->host_scribble)
+#define ASSIGN_SAS_TASK(_sc, _t) do { (_sc)->host_scribble = (void *) _t; } while (0)
+
+static void sas_scsi_task_done(struct sas_task *task)
+{
+        struct task_status_struct *ts = &task->task_status;
+        struct scsi_cmnd *sc = task->uldd_task;
+        unsigned ts_flags = task->task_state_flags;
+        int hs = 0, stat = 0;
+
+        if (unlikely(!sc)) {
+                SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n");
+                list_del_init(&task->list);
+                sas_free_task(task);
+                return;
+        }
+
+        if (ts->resp == SAS_TASK_UNDELIVERED) {
+                /* transport error */
+                hs = DID_NO_CONNECT;
+        } else { /* ts->resp == SAS_TASK_COMPLETE */
+                /* task delivered, what happened afterwards? */
+                switch (ts->stat) {
+                case SAS_DEV_NO_RESPONSE:
+                case SAS_INTERRUPTED:
+                case SAS_PHY_DOWN:
+                case SAS_NAK_R_ERR:
+                case SAS_OPEN_TO:
+                        hs = DID_NO_CONNECT;
+                        break;
+                case SAS_DATA_UNDERRUN:
+                        sc->resid = ts->residual;
+                        if (sc->request_bufflen - sc->resid < sc->underflow)
+                                hs = DID_ERROR;
+                        break;
+                case SAS_DATA_OVERRUN:
+                        hs = DID_ERROR;
+                        break;
+                case SAS_QUEUE_FULL:
+                        hs = DID_SOFT_ERROR; /* retry */
+                        break;
+                case SAS_DEVICE_UNKNOWN:
+                        hs = DID_BAD_TARGET;
+                        break;
+                case SAS_SG_ERR:
+                        hs = DID_PARITY;
+                        break;
+                case SAS_OPEN_REJECT:
+                        if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY)
+                                hs = DID_SOFT_ERROR; /* retry */
+                        else
+                                hs = DID_ERROR;
+                        break;
+                case SAS_PROTO_RESPONSE:
+                        SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP "
+                                    "task; please report this\n",
+                                    task->dev->port->ha->sas_ha_name);
+                        break;
+                case SAS_ABORTED_TASK:
+                        hs = DID_ABORT;
+                        break;
+                case SAM_CHECK_COND:
+                        memcpy(sc->sense_buffer, ts->buf,
+                               max(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size));
+                        stat = SAM_CHECK_COND;
+                        break;
+                default:
+                        stat = ts->stat;
+                        break;
+                }
+        }
+        ASSIGN_SAS_TASK(sc, NULL);
+        sc->result = (hs << 16) | stat;
+        list_del_init(&task->list);
+        sas_free_task(task);
+        /* This is very ugly but this is how SCSI Core works. */
+        if (ts_flags & SAS_TASK_STATE_ABORTED)
+                scsi_finish_command(sc);
+        else
+                sc->scsi_done(sc);
+}
+
+static enum task_attribute sas_scsi_get_task_attr(struct scsi_cmnd *cmd)
+{
+        enum task_attribute ta = TASK_ATTR_SIMPLE;
+        if (cmd->request && blk_rq_tagged(cmd->request)) {
+                if (cmd->device->ordered_tags &&
+                    (cmd->request->flags & REQ_HARDBARRIER))
+                        ta = TASK_ATTR_HOQ;
+        }
+        return ta;
+}
+
+static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
+                                               struct domain_device *dev,
+                                               unsigned long gfp_flags)
+{
+        struct sas_task *task = sas_alloc_task(gfp_flags);
+        struct scsi_lun lun;
+
+        if (!task)
+                return NULL;
+
+        *(u32 *)cmd->sense_buffer = 0;
+        task->uldd_task = cmd;
+        ASSIGN_SAS_TASK(cmd, task);
+
+        task->dev = dev;
+        task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */
+
+        task->ssp_task.retry_count = 1;
+        int_to_scsilun(cmd->device->lun, &lun);
+        memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8);
+        task->ssp_task.task_attr = sas_scsi_get_task_attr(cmd);
+        memcpy(task->ssp_task.cdb, cmd->cmnd, 16);
+
+        task->scatter = cmd->request_buffer;
+        task->num_scatter = cmd->use_sg;
+        task->total_xfer_len = cmd->request_bufflen;
+        task->data_dir = cmd->sc_data_direction;
+
+        task->task_done = sas_scsi_task_done;
+
+        return task;
+}
+
+static int sas_queue_up(struct sas_task *task)
+{
+        struct sas_ha_struct *sas_ha = task->dev->port->ha;
+        struct scsi_core *core = &sas_ha->core;
+        unsigned long flags;
+        LIST_HEAD(list);
+
+        spin_lock_irqsave(&core->task_queue_lock, flags);
+        if (sas_ha->lldd_queue_size < core->task_queue_size + 1) {
+                spin_unlock_irqrestore(&core->task_queue_lock, flags);
+                return -SAS_QUEUE_FULL;
+        }
+        list_add_tail(&task->list, &core->task_queue);
+        core->task_queue_size += 1;
+        spin_unlock_irqrestore(&core->task_queue_lock, flags);
+        up(&core->queue_thread_sema);
+
+        return 0;
+}
+
+/**
+ * sas_queuecommand -- Enqueue a command for processing
+ * @parameters: See SCSI Core documentation
+ *
+ * Note: XXX: Remove the host unlock/lock pair when SCSI Core can
+ * call us without holding an IRQ spinlock...
+ */
+int sas_queuecommand(struct scsi_cmnd *cmd,
+                     void (*scsi_done)(struct scsi_cmnd *))
+{
+        int res = 0;
+        struct domain_device *dev = cmd_to_domain_dev(cmd);
+        struct Scsi_Host *host = cmd->device->host;
+        struct sas_internal *i = to_sas_internal(host->transportt);
+
+        spin_unlock_irq(host->host_lock);
+
+        {
+                struct sas_ha_struct *sas_ha = dev->port->ha;
+                struct sas_task *task;
+
+                res = -ENOMEM;
+                task = sas_create_task(cmd, dev, GFP_ATOMIC);
+                if (!task)
+                        goto out;
+
+                cmd->scsi_done = scsi_done;
+                /* Queue up, Direct Mode or Task Collector Mode. */
+                if (sas_ha->lldd_max_execute_num < 2)
+                        res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
+                else
+                        res = sas_queue_up(task);
+
+                /* Examine */
+                if (res) {
+                        SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
+                        ASSIGN_SAS_TASK(cmd, NULL);
+                        sas_free_task(task);
+                        if (res == -SAS_QUEUE_FULL) {
+                                cmd->result = DID_SOFT_ERROR << 16; /* retry */
+                                res = 0;
+                                scsi_done(cmd);
+                        }
+                        goto out;
+                }
+        }
+out:
+        spin_lock_irq(host->host_lock);
+        return res;
+}
+
+static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd)
+{
+        struct scsi_cmnd *cmd, *n;
+
+        list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
+                if (cmd == my_cmd)
+                        list_del_init(&cmd->eh_entry);
+        }
+}
+
+static void sas_scsi_clear_queue_I_T(struct list_head *error_q,
+                                     struct domain_device *dev)
+{
+        struct scsi_cmnd *cmd, *n;
+
+        list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
+                struct domain_device *x = cmd_to_domain_dev(cmd);
+
+                if (x == dev)
+                        list_del_init(&cmd->eh_entry);
+        }
+}
+
+static void sas_scsi_clear_queue_port(struct list_head *error_q,
+                                      struct asd_sas_port *port)
+{
+        struct scsi_cmnd *cmd, *n;
+
+        list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
+                struct domain_device *dev = cmd_to_domain_dev(cmd);
+                struct asd_sas_port *x = dev->port;
+
+                if (x == port)
+                        list_del_init(&cmd->eh_entry);
+        }
+}
+
+enum task_disposition {
+        TASK_IS_DONE,
+        TASK_IS_ABORTED,
+        TASK_IS_AT_LU,
+        TASK_IS_NOT_AT_LU,
+};
+
+static enum task_disposition sas_scsi_find_task(struct sas_task *task)
+{
+        struct sas_ha_struct *ha = task->dev->port->ha;
+        unsigned long flags;
+        int i, res;
+        struct sas_internal *si =
+                to_sas_internal(task->dev->port->ha->core.shost->transportt);
+
+        if (ha->lldd_max_execute_num > 1) {
+                struct scsi_core *core = &ha->core;
+                struct sas_task *t, *n;
+
+                spin_lock_irqsave(&core->task_queue_lock, flags);
+                list_for_each_entry_safe(t, n, &core->task_queue, list) {
+                        if (task == t) {
+                                list_del_init(&t->list);
+                                spin_unlock_irqrestore(&core->task_queue_lock,
+                                                       flags);
+                                SAS_DPRINTK("%s: task 0x%p aborted from "
+                                            "task_queue\n",
+                                            __FUNCTION__, task);
+                                return TASK_IS_ABORTED;
+                        }
+                }
+                spin_unlock_irqrestore(&core->task_queue_lock, flags);
+        }
+
+        for (i = 0; i < 5; i++) {
+                SAS_DPRINTK("%s: aborting task 0x%p\n", __FUNCTION__, task);
+                res = si->dft->lldd_abort_task(task);
+
+                spin_lock_irqsave(&task->task_state_lock, flags);
+                if (task->task_state_flags & SAS_TASK_STATE_DONE) {
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+                        SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__,
+                                    task);
+                        return TASK_IS_DONE;
+                }
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                if (res == TMF_RESP_FUNC_COMPLETE) {
+                        SAS_DPRINTK("%s: task 0x%p is aborted\n",
+                                    __FUNCTION__, task);
+                        return TASK_IS_ABORTED;
+                } else if (si->dft->lldd_query_task) {
+                        SAS_DPRINTK("%s: querying task 0x%p\n",
+                                    __FUNCTION__, task);
+                        res = si->dft->lldd_query_task(task);
+                        if (res == TMF_RESP_FUNC_SUCC) {
+                                SAS_DPRINTK("%s: task 0x%p at LU\n",
+                                            __FUNCTION__, task);
+                                return TASK_IS_AT_LU;
+                        } else if (res == TMF_RESP_FUNC_COMPLETE) {
+                                SAS_DPRINTK("%s: task 0x%p not at LU\n",
+                                            __FUNCTION__, task);
+                                return TASK_IS_NOT_AT_LU;
+                        }
+                }
+        }
+        return res;
+}
+
+static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd)
+{
+        int res = TMF_RESP_FUNC_FAILED;
+        struct scsi_lun lun;
+        struct sas_internal *i =
+                to_sas_internal(dev->port->ha->core.shost->transportt);
+
+        int_to_scsilun(cmd->device->lun, &lun);
+
+        SAS_DPRINTK("eh: device %llx LUN %x has the task\n",
+                    SAS_ADDR(dev->sas_addr),
+                    cmd->device->lun);
+
+        if (i->dft->lldd_abort_task_set)
+                res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun);
+
+        if (res == TMF_RESP_FUNC_FAILED) {
+                if (i->dft->lldd_clear_task_set)
+                        res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun);
+        }
+
+        if (res == TMF_RESP_FUNC_FAILED) {
+                if (i->dft->lldd_lu_reset)
+                        res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
+        }
+
+        return res;
+}
+
+static int sas_recover_I_T(struct domain_device *dev)
+{
+        int res = TMF_RESP_FUNC_FAILED;
+        struct sas_internal *i =
+                to_sas_internal(dev->port->ha->core.shost->transportt);
+
+        SAS_DPRINTK("I_T nexus reset for dev %016llx\n",
+                    SAS_ADDR(dev->sas_addr));
+
+        if (i->dft->lldd_I_T_nexus_reset)
+                res = i->dft->lldd_I_T_nexus_reset(dev);
+
+        return res;
+}
+
+void sas_scsi_recover_host(struct Scsi_Host *shost)
+{
+        struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
+        unsigned long flags;
+        LIST_HEAD(error_q);
+        struct scsi_cmnd *cmd, *n;
+        enum task_disposition res = TASK_IS_DONE;
+        int tmf_resp;
+        struct sas_internal *i = to_sas_internal(shost->transportt);
+
+        spin_lock_irqsave(shost->host_lock, flags);
+        list_splice_init(&shost->eh_cmd_q, &error_q);
+        spin_unlock_irqrestore(shost->host_lock, flags);
+
+        SAS_DPRINTK("Enter %s\n", __FUNCTION__);
+
+        /* All tasks on this list were marked SAS_TASK_STATE_ABORTED
+         * by sas_scsi_timed_out() callback.
+         */
+Again:
+        SAS_DPRINTK("going over list...\n");
+        list_for_each_entry_safe(cmd, n, &error_q, eh_entry) {
+                struct sas_task *task = TO_SAS_TASK(cmd);
+
+                SAS_DPRINTK("trying to find task 0x%p\n", task);
+                list_del_init(&cmd->eh_entry);
+                res = sas_scsi_find_task(task);
+
+                cmd->eh_eflags = 0;
+                shost->host_failed--;
+
+                switch (res) {
+                case TASK_IS_DONE:
+                        SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__,
+                                    task);
+                        task->task_done(task);
+                        continue;
+                case TASK_IS_ABORTED:
+                        SAS_DPRINTK("%s: task 0x%p is aborted\n",
+                                    __FUNCTION__, task);
+                        task->task_done(task);
+                        continue;
+                case TASK_IS_AT_LU:
+                        SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task);
+                        tmf_resp = sas_recover_lu(task->dev, cmd);
+                        if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
+                                SAS_DPRINTK("dev %016llx LU %x is "
+                                            "recovered\n",
+                                            SAS_ADDR(task->dev),
+                                            cmd->device->lun);
+                                task->task_done(task);
+                                sas_scsi_clear_queue_lu(&error_q, cmd);
+                                goto Again;
+                        }
+                        /* fallthrough */
+                case TASK_IS_NOT_AT_LU:
+                        SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n",
+                                    task);
+                        tmf_resp = sas_recover_I_T(task->dev);
+                        if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
+                                SAS_DPRINTK("I_T %016llx recovered\n",
+                                            SAS_ADDR(task->dev->sas_addr));
+                                task->task_done(task);
+                                sas_scsi_clear_queue_I_T(&error_q, task->dev);
+                                goto Again;
+                        }
+                        /* Hammer time :-) */
+                        if (i->dft->lldd_clear_nexus_port) {
+                                struct asd_sas_port *port = task->dev->port;
+                                SAS_DPRINTK("clearing nexus for port:%d\n",
+                                            port->id);
+                                res = i->dft->lldd_clear_nexus_port(port);
+                                if (res == TMF_RESP_FUNC_COMPLETE) {
+                                        SAS_DPRINTK("clear nexus port:%d "
+                                                    "succeeded\n", port->id);
+                                        task->task_done(task);
+                                        sas_scsi_clear_queue_port(&error_q,
+                                                                  port);
+                                        goto Again;
+                                }
+                        }
+                        if (i->dft->lldd_clear_nexus_ha) {
+                                SAS_DPRINTK("clear nexus ha\n");
+                                res = i->dft->lldd_clear_nexus_ha(ha);
+                                if (res == TMF_RESP_FUNC_COMPLETE) {
+                                        SAS_DPRINTK("clear nexus ha "
+                                                    "succeeded\n");
+                                        task->task_done(task);
+                                        goto out;
+                                }
+                        }
+                        /* If we are here -- this means that no amount
+                         * of effort could recover from errors.  Quite
+                         * possibly the HA just disappeared.
+                         */
+                        SAS_DPRINTK("error from  device %llx, LUN %x "
+                                    "couldn't be recovered in any way\n",
+                                    SAS_ADDR(task->dev->sas_addr),
+                                    cmd->device->lun);
+
+                        task->task_done(task);
+                        goto clear_q;
+                }
+        }
+out:
+        SAS_DPRINTK("--- Exit %s\n", __FUNCTION__);
+        return;
+clear_q:
+        SAS_DPRINTK("--- Exit %s -- clear_q\n", __FUNCTION__);
+        list_for_each_entry_safe(cmd, n, &error_q, eh_entry) {
+                struct sas_task *task = TO_SAS_TASK(cmd);
+                list_del_init(&cmd->eh_entry);
+                task->task_done(task);
+        }
+}
+
+enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
+{
+        struct sas_task *task = TO_SAS_TASK(cmd);
+        unsigned long flags;
+
+        if (!task) {
+                SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_HANDLED\n",
+                            cmd, task);
+                return EH_HANDLED;
+        }
+
+        spin_lock_irqsave(&task->task_state_lock, flags);
+        if (task->task_state_flags & SAS_TASK_STATE_DONE) {
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
+                SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_HANDLED\n",
+                            cmd, task);
+                return EH_HANDLED;
+        }
+        task->task_state_flags |= SAS_TASK_STATE_ABORTED;
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+        SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_NOT_HANDLED\n",
+                    cmd, task);
+
+        return EH_NOT_HANDLED;
+}
+
+struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy)
+{
+        struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent);
+        struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
+        struct domain_device *found_dev = NULL;
+        int i;
+
+        spin_lock(&ha->phy_port_lock);
+        for (i = 0; i < ha->num_phys; i++) {
+                struct asd_sas_port *port = ha->sas_port[i];
+                struct domain_device *dev;
+
+                spin_lock(&port->dev_list_lock);
+                list_for_each_entry(dev, &port->dev_list, dev_list_node) {
+                        if (rphy == dev->rphy) {
+                                found_dev = dev;
+                                spin_unlock(&port->dev_list_lock);
+                                goto found;
+                        }
+                }
+                spin_unlock(&port->dev_list_lock);
+        }
+ found:
+        spin_unlock(&ha->phy_port_lock);
+
+        return found_dev;
+}
+
+static inline struct domain_device *sas_find_target(struct scsi_target *starget)
+{
+        struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent);
+
+        return sas_find_dev_by_rphy(rphy);
+}
+
+int sas_target_alloc(struct scsi_target *starget)
+{
+        struct domain_device *found_dev = sas_find_target(starget);
+
+        if (!found_dev)
+                return -ENODEV;
+
+        starget->hostdata = found_dev;
+        return 0;
+}
+
+#define SAS_DEF_QD 32
+#define SAS_MAX_QD 64
+
+int sas_slave_configure(struct scsi_device *scsi_dev)
+{
+        struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
+        struct sas_ha_struct *sas_ha;
+
+        BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE);
+
+        sas_ha = dev->port->ha;
+
+        sas_read_port_mode_page(scsi_dev);
+
+        if (scsi_dev->tagged_supported) {
+                scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG);
+                scsi_activate_tcq(scsi_dev, SAS_DEF_QD);
+        } else {
+                SAS_DPRINTK("device %llx, LUN %x doesn't support "
+                            "TCQ\n", SAS_ADDR(dev->sas_addr),
+                            scsi_dev->lun);
+                scsi_dev->tagged_supported = 0;
+                scsi_set_tag_type(scsi_dev, 0);
+                scsi_deactivate_tcq(scsi_dev, 1);
+        }
+
+        return 0;
+}
+
+void sas_slave_destroy(struct scsi_device *scsi_dev)
+{
+}
+
+int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth)
+{
+        int res = min(new_depth, SAS_MAX_QD);
+
+        if (scsi_dev->tagged_supported)
+                scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev),
+                                        res);
+        else {
+                struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
+                sas_printk("device %llx LUN %x queue depth changed to 1\n",
+                           SAS_ADDR(dev->sas_addr),
+                           scsi_dev->lun);
+                scsi_adjust_queue_depth(scsi_dev, 0, 1);
+                res = 1;
+        }
+
+        return res;
+}
+
+int sas_change_queue_type(struct scsi_device *scsi_dev, int qt)
+{
+        if (!scsi_dev->tagged_supported)
+                return 0;
+
+        scsi_deactivate_tcq(scsi_dev, 1);
+
+        scsi_set_tag_type(scsi_dev, qt);
+        scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
+
+        return qt;
+}
+
+int sas_bios_param(struct scsi_device *scsi_dev,
+                          struct block_device *bdev,
+                          sector_t capacity, int *hsc)
+{
+        hsc[0] = 255;
+        hsc[1] = 63;
+        sector_div(capacity, 255*63);
+        hsc[2] = capacity;
+
+        return 0;
+}
+
+/* ---------- Task Collector Thread implementation ---------- */
+
+static void sas_queue(struct sas_ha_struct *sas_ha)
+{
+        struct scsi_core *core = &sas_ha->core;
+        unsigned long flags;
+        LIST_HEAD(q);
+        int can_queue;
+        int res;
+        struct sas_internal *i = to_sas_internal(core->shost->transportt);
+
+        spin_lock_irqsave(&core->task_queue_lock, flags);
+        while (!core->queue_thread_kill &&
+               !list_empty(&core->task_queue)) {
+
+                can_queue = sas_ha->lldd_queue_size - core->task_queue_size;
+                if (can_queue >= 0) {
+                        can_queue = core->task_queue_size;
+                        list_splice_init(&core->task_queue, &q);
+                } else {
+                        struct list_head *a, *n;
+
+                        can_queue = sas_ha->lldd_queue_size;
+                        list_for_each_safe(a, n, &core->task_queue) {
+                                list_move_tail(a, &q);
+                                if (--can_queue == 0)
+                                        break;
+                        }
+                        can_queue = sas_ha->lldd_queue_size;
+                }
+                core->task_queue_size -= can_queue;
+                spin_unlock_irqrestore(&core->task_queue_lock, flags);
+                {
+                        struct sas_task *task = list_entry(q.next,
+                                                           struct sas_task,
+                                                           list);
+                        list_del_init(&q);
+                        res = i->dft->lldd_execute_task(task, can_queue,
+                                                        GFP_KERNEL);
+                        if (unlikely(res))
+                                __list_add(&q, task->list.prev, &task->list);
+                }
+                spin_lock_irqsave(&core->task_queue_lock, flags);
+                if (res) {
+                        list_splice_init(&q, &core->task_queue); /*at head*/
+                        core->task_queue_size += can_queue;
+                }
+        }
+        spin_unlock_irqrestore(&core->task_queue_lock, flags);
+}
+
+static DECLARE_COMPLETION(queue_th_comp);
+
+/**
+ * sas_queue_thread -- The Task Collector thread
+ * @_sas_ha: pointer to struct sas_ha
+ */
+static int sas_queue_thread(void *_sas_ha)
+{
+        struct sas_ha_struct *sas_ha = _sas_ha;
+        struct scsi_core *core = &sas_ha->core;
+
+        daemonize("sas_queue_%d", core->shost->host_no);
+        current->flags |= PF_NOFREEZE;
+
+        complete(&queue_th_comp);
+
+        while (1) {
+                down_interruptible(&core->queue_thread_sema);
+                sas_queue(sas_ha);
+                if (core->queue_thread_kill)
+                        break;
+        }
+
+        complete(&queue_th_comp);
+
+        return 0;
+}
+
+int sas_init_queue(struct sas_ha_struct *sas_ha)
+{
+        int res;
+        struct scsi_core *core = &sas_ha->core;
+
+        spin_lock_init(&core->task_queue_lock);
+        core->task_queue_size = 0;
+        INIT_LIST_HEAD(&core->task_queue);
+        init_MUTEX_LOCKED(&core->queue_thread_sema);
+
+        res = kernel_thread(sas_queue_thread, sas_ha, 0);
+        if (res >= 0)
+                wait_for_completion(&queue_th_comp);
+
+        return res < 0 ? res : 0;
+}
+
+void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
+{
+        unsigned long flags;
+        struct scsi_core *core = &sas_ha->core;
+        struct sas_task *task, *n;
+
+        init_completion(&queue_th_comp);
+        core->queue_thread_kill = 1;
+        up(&core->queue_thread_sema);
+        wait_for_completion(&queue_th_comp);
+
+        if (!list_empty(&core->task_queue))
+                SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n",
+                            SAS_ADDR(sas_ha->sas_addr));
+
+        spin_lock_irqsave(&core->task_queue_lock, flags);
+        list_for_each_entry_safe(task, n, &core->task_queue, list) {
+                struct scsi_cmnd *cmd = task->uldd_task;
+
+                list_del_init(&task->list);
+
+                ASSIGN_SAS_TASK(cmd, NULL);
+                sas_free_task(task);
+                cmd->result = DID_ABORT << 16;
+                cmd->scsi_done(cmd);
+        }
+        spin_unlock_irqrestore(&core->task_queue_lock, flags);
+}
+
+EXPORT_SYMBOL_GPL(sas_queuecommand);
+EXPORT_SYMBOL_GPL(sas_target_alloc);
+EXPORT_SYMBOL_GPL(sas_slave_configure);
+EXPORT_SYMBOL_GPL(sas_slave_destroy);
+EXPORT_SYMBOL_GPL(sas_change_queue_depth);
+EXPORT_SYMBOL_GPL(sas_change_queue_type);
+EXPORT_SYMBOL_GPL(sas_bios_param);