/*
 *  linux/drivers/scsi/esas2r/esas2r_disc.c
 *      esas2r device discovery routines
 *
 *  Copyright (c) 2001-2013 ATTO Technology, Inc.
 *  (mailto:linuxdrivers@attotech.com)
 */
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  NO WARRANTY
 *  THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
 *  CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
 *  LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
 *  MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
 *  solely responsible for determining the appropriateness of using and
 *  distributing the Program and assumes all risks associated with its
 *  exercise of rights under this Agreement, including but not limited to
 *  the risks and costs of program errors, damage to or loss of data,
 *  programs or equipment, and unavailability or interruption of operations.
 *
 *  DISCLAIMER OF LIABILITY
 *  NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
 *  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 *  USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
 *  HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
 *
 *  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 "esas2r.h"

/* Miscellaneous internal discovery routines */
static void esas2r_disc_abort(struct esas2r_adapter *a,
                              struct esas2r_request *rq);
static bool esas2r_disc_continue(struct esas2r_adapter *a,
                                 struct esas2r_request *rq);
static void esas2r_disc_fix_curr_requests(struct esas2r_adapter *a);
static u32 esas2r_disc_get_phys_addr(struct esas2r_sg_context *sgc, u64 *addr);
static bool esas2r_disc_start_request(struct esas2r_adapter *a,
                                      struct esas2r_request *rq);

/* Internal discovery routines that process the states */
static bool esas2r_disc_block_dev_scan(struct esas2r_adapter *a,
                                       struct esas2r_request *rq);
static void esas2r_disc_block_dev_scan_cb(struct esas2r_adapter *a,
                                          struct esas2r_request *rq);
static bool esas2r_disc_dev_add(struct esas2r_adapter *a,
                                struct esas2r_request *rq);
static bool esas2r_disc_dev_remove(struct esas2r_adapter *a,
                                   struct esas2r_request *rq);
static bool esas2r_disc_part_info(struct esas2r_adapter *a,
                                  struct esas2r_request *rq);
static void esas2r_disc_part_info_cb(struct esas2r_adapter *a,
                                     struct esas2r_request *rq);
static bool esas2r_disc_passthru_dev_info(struct esas2r_adapter *a,
                                          struct esas2r_request *rq);
static void esas2r_disc_passthru_dev_info_cb(struct esas2r_adapter *a,
                                             struct esas2r_request *rq);
static bool esas2r_disc_passthru_dev_addr(struct esas2r_adapter *a,
                                          struct esas2r_request *rq);
static void esas2r_disc_passthru_dev_addr_cb(struct esas2r_adapter *a,
                                             struct esas2r_request *rq);
static bool esas2r_disc_raid_grp_info(struct esas2r_adapter *a,
                                      struct esas2r_request *rq);
static void esas2r_disc_raid_grp_info_cb(struct esas2r_adapter *a,
                                         struct esas2r_request *rq);

void esas2r_disc_initialize(struct esas2r_adapter *a)
{
        struct esas2r_sas_nvram *nvr = a->nvram;

        esas2r_trace_enter();

        clear_bit(AF_DISC_IN_PROG, &a->flags);
        clear_bit(AF2_DEV_SCAN, &a->flags2);
        clear_bit(AF2_DEV_CNT_OK, &a->flags2);

        a->disc_start_time = jiffies_to_msecs(jiffies);
        a->disc_wait_time = nvr->dev_wait_time * 1000;
        a->disc_wait_cnt = nvr->dev_wait_count;

        if (a->disc_wait_cnt > ESAS2R_MAX_TARGETS)
                a->disc_wait_cnt = ESAS2R_MAX_TARGETS;

        /*
         * If we are doing chip reset or power management processing, always
         * wait for devices.  use the NVRAM device count if it is greater than
         * previously discovered devices.
         */

        esas2r_hdebug("starting discovery...");

        a->general_req.interrupt_cx = NULL;

        if (test_bit(AF_CHPRST_DETECTED, &a->flags) ||
            test_bit(AF_POWER_MGT, &a->flags)) {
                if (a->prev_dev_cnt == 0) {
                        /* Don't bother waiting if there is nothing to wait
                         * for.
                         */
                        a->disc_wait_time = 0;
                } else {
                        /*
                         * Set the device wait count to what was previously
                         * found.  We don't care if the user only configured
                         * a time because we know the exact count to wait for.
                         * There is no need to honor the user's wishes to
                         * always wait the full time.
                         */
                        a->disc_wait_cnt = a->prev_dev_cnt;

                        /*
                         * bump the minimum wait time to 15 seconds since the
                         * default is 3 (system boot or the boot driver usually
                         * buys us more time).
                         */
                        if (a->disc_wait_time < 15000)
                                a->disc_wait_time = 15000;
                }
        }

        esas2r_trace("disc wait count: %d", a->disc_wait_cnt);
        esas2r_trace("disc wait time: %d", a->disc_wait_time);

        if (a->disc_wait_time == 0)
                esas2r_disc_check_complete(a);

        esas2r_trace_exit();
}

void esas2r_disc_start_waiting(struct esas2r_adapter *a)
{
        unsigned long flags;

        spin_lock_irqsave(&a->mem_lock, flags);

        if (a->disc_ctx.disc_evt)
                esas2r_disc_start_port(a);

        spin_unlock_irqrestore(&a->mem_lock, flags);
}

void esas2r_disc_check_for_work(struct esas2r_adapter *a)
{
        struct esas2r_request *rq = &a->general_req;

        /* service any pending interrupts first */

        esas2r_polled_interrupt(a);

        /*
         * now, interrupt processing may have queued up a discovery event.  go
         * see if we have one to start.  we couldn't start it in the ISR since
         * polled discovery would cause a deadlock.
         */

        esas2r_disc_start_waiting(a);

        if (rq->interrupt_cx == NULL)
                return;

        if (rq->req_stat == RS_STARTED
            && rq->timeout <= RQ_MAX_TIMEOUT) {
                /* wait for the current discovery request to complete. */
                esas2r_wait_request(a, rq);

                if (rq->req_stat == RS_TIMEOUT) {
                        esas2r_disc_abort(a, rq);
                        esas2r_local_reset_adapter(a);
                        return;
                }
        }

        if (rq->req_stat == RS_PENDING
            || rq->req_stat == RS_STARTED)
                return;

        esas2r_disc_continue(a, rq);
}

void esas2r_disc_check_complete(struct esas2r_adapter *a)
{
        unsigned long flags;

        esas2r_trace_enter();

        /* check to see if we should be waiting for devices */
        if (a->disc_wait_time) {
                u32 currtime = jiffies_to_msecs(jiffies);
                u32 time = currtime - a->disc_start_time;

                /*
                 * Wait until the device wait time is exhausted or the device
                 * wait count is satisfied.
                 */
                if (time < a->disc_wait_time
                    && (esas2r_targ_db_get_tgt_cnt(a) < a->disc_wait_cnt
                        || a->disc_wait_cnt == 0)) {
                        /* After three seconds of waiting, schedule a scan. */
                        if (time >= 3000
                            && !test_and_set_bit(AF2_DEV_SCAN, &a->flags2)) {
                                spin_lock_irqsave(&a->mem_lock, flags);
                                esas2r_disc_queue_event(a, DCDE_DEV_SCAN);
                                spin_unlock_irqrestore(&a->mem_lock, flags);
                        }

                        esas2r_trace_exit();
                        return;
                }

                /*
                 * We are done waiting...we think.  Adjust the wait time to
                 * consume events after the count is met.
                 */
                if (!test_and_set_bit(AF2_DEV_CNT_OK, &a->flags2))
                        a->disc_wait_time = time + 3000;

                /* If we haven't done a full scan yet, do it now. */
                if (!test_and_set_bit(AF2_DEV_SCAN, &a->flags2)) {
                        spin_lock_irqsave(&a->mem_lock, flags);
                        esas2r_disc_queue_event(a, DCDE_DEV_SCAN);
                        spin_unlock_irqrestore(&a->mem_lock, flags);
                        esas2r_trace_exit();
                        return;
                }

                /*
                 * Now, if there is still time left to consume events, continue
                 * waiting.
                 */
                if (time < a->disc_wait_time) {
                        esas2r_trace_exit();
                        return;
                }
        } else {
                if (!test_and_set_bit(AF2_DEV_SCAN, &a->flags2)) {
                        spin_lock_irqsave(&a->mem_lock, flags);
                        esas2r_disc_queue_event(a, DCDE_DEV_SCAN);
                        spin_unlock_irqrestore(&a->mem_lock, flags);
                }
        }

        /* We want to stop waiting for devices. */
        a->disc_wait_time = 0;

        if (test_bit(AF_DISC_POLLED, &a->flags) &&
            test_bit(AF_DISC_IN_PROG, &a->flags)) {
                /*
                 * Polled discovery is still pending so continue the active
                 * discovery until it is done.  At that point, we will stop
                 * polled discovery and transition to interrupt driven
                 * discovery.
                 */
        } else {
                /*
                 * Done waiting for devices.  Note that we get here immediately
                 * after deferred waiting completes because that is interrupt
                 * driven; i.e. There is no transition.
                 */
                esas2r_disc_fix_curr_requests(a);
                clear_bit(AF_DISC_PENDING, &a->flags);

                /*
                 * We have deferred target state changes until now because we
                 * don't want to report any removals (due to the first arrival)
                 * until the device wait time expires.
                 */
                set_bit(AF_PORT_CHANGE, &a->flags);
        }

        esas2r_trace_exit();
}

void esas2r_disc_queue_event(struct esas2r_adapter *a, u8 disc_evt)
{
        struct esas2r_disc_context *dc = &a->disc_ctx;

        esas2r_trace_enter();

        esas2r_trace("disc_event: %d", disc_evt);

        /* Initialize the discovery context */
        dc->disc_evt |= disc_evt;

        /*
         * Don't start discovery before or during polled discovery.  if we did,
         * we would have a deadlock if we are in the ISR already.
         */
        if (!test_bit(AF_CHPRST_PENDING, &a->flags) &&
            !test_bit(AF_DISC_POLLED, &a->flags))
                esas2r_disc_start_port(a);

        esas2r_trace_exit();
}

bool esas2r_disc_start_port(struct esas2r_adapter *a)
{
        struct esas2r_request *rq = &a->general_req;
        struct esas2r_disc_context *dc = &a->disc_ctx;
        bool ret;

        esas2r_trace_enter();

        if (test_bit(AF_DISC_IN_PROG, &a->flags)) {
                esas2r_trace_exit();

                return false;
        }

        /* If there is a discovery waiting, process it. */
        if (dc->disc_evt) {
                if (test_bit(AF_DISC_POLLED, &a->flags)
                    && a->disc_wait_time == 0) {
                        /*
                         * We are doing polled discovery, but we no longer want
                         * to wait for devices.  Stop polled discovery and
                         * transition to interrupt driven discovery.
                         */

                        esas2r_trace_exit();

                        return false;
                }
        } else {
                /* Discovery is complete. */

                esas2r_hdebug("disc done");

                set_bit(AF_PORT_CHANGE, &a->flags);

                esas2r_trace_exit();

                return false;
        }

        /* Handle the discovery context */
        esas2r_trace("disc_evt: %d", dc->disc_evt);
        set_bit(AF_DISC_IN_PROG, &a->flags);
        dc->flags = 0;

        if (test_bit(AF_DISC_POLLED, &a->flags))
                dc->flags |= DCF_POLLED;

        rq->interrupt_cx = dc;
        rq->req_stat = RS_SUCCESS;

        /* Decode the event code */
        if (dc->disc_evt & DCDE_DEV_SCAN) {
                dc->disc_evt &= ~DCDE_DEV_SCAN;

                dc->flags |= DCF_DEV_SCAN;
                dc->state = DCS_BLOCK_DEV_SCAN;
        } else if (dc->disc_evt & DCDE_DEV_CHANGE) {
                dc->disc_evt &= ~DCDE_DEV_CHANGE;

                dc->flags |= DCF_DEV_CHANGE;
                dc->state = DCS_DEV_RMV;
        }

        /* Continue interrupt driven discovery */
        if (!test_bit(AF_DISC_POLLED, &a->flags))
                ret = esas2r_disc_continue(a, rq);
        else
                ret = true;

        esas2r_trace_exit();

        return ret;
}

static bool esas2r_disc_continue(struct esas2r_adapter *a,
                                 struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        bool rslt;

        /* Device discovery/removal */
        while (dc->flags & (DCF_DEV_CHANGE | DCF_DEV_SCAN)) {
                rslt = false;

                switch (dc->state) {
                case DCS_DEV_RMV:

                        rslt = esas2r_disc_dev_remove(a, rq);
                        break;

                case DCS_DEV_ADD:

                        rslt = esas2r_disc_dev_add(a, rq);
                        break;

                case DCS_BLOCK_DEV_SCAN:

                        rslt = esas2r_disc_block_dev_scan(a, rq);
                        break;

                case DCS_RAID_GRP_INFO:

                        rslt = esas2r_disc_raid_grp_info(a, rq);
                        break;

                case DCS_PART_INFO:

                        rslt = esas2r_disc_part_info(a, rq);
                        break;

                case DCS_PT_DEV_INFO:

                        rslt = esas2r_disc_passthru_dev_info(a, rq);
                        break;
                case DCS_PT_DEV_ADDR:

                        rslt = esas2r_disc_passthru_dev_addr(a, rq);
                        break;
                case DCS_DISC_DONE:

                        dc->flags &= ~(DCF_DEV_CHANGE | DCF_DEV_SCAN);
                        break;

                default:

                        esas2r_bugon();
                        dc->state = DCS_DISC_DONE;
                        break;
                }

                if (rslt)
                        return true;
        }

        /* Discovery is done...for now. */
        rq->interrupt_cx = NULL;

        if (!test_bit(AF_DISC_PENDING, &a->flags))
                esas2r_disc_fix_curr_requests(a);

        clear_bit(AF_DISC_IN_PROG, &a->flags);

        /* Start the next discovery. */
        return esas2r_disc_start_port(a);
}

static bool esas2r_disc_start_request(struct esas2r_adapter *a,
                                      struct esas2r_request *rq)
{
        unsigned long flags;

        /* Set the timeout to a minimum value. */
        if (rq->timeout < ESAS2R_DEFAULT_TMO)
                rq->timeout = ESAS2R_DEFAULT_TMO;

        /*
         * Override the request type to distinguish discovery requests.  If we
         * end up deferring the request, esas2r_disc_local_start_request()
         * will be called to restart it.
         */
        rq->req_type = RT_DISC_REQ;

        spin_lock_irqsave(&a->queue_lock, flags);

        if (!test_bit(AF_CHPRST_PENDING, &a->flags) &&
            !test_bit(AF_FLASHING, &a->flags))
                esas2r_disc_local_start_request(a, rq);
        else
                list_add_tail(&rq->req_list, &a->defer_list);

        spin_unlock_irqrestore(&a->queue_lock, flags);

        return true;
}

void esas2r_disc_local_start_request(struct esas2r_adapter *a,
                                     struct esas2r_request *rq)
{
        esas2r_trace_enter();

        list_add_tail(&rq->req_list, &a->active_list);

        esas2r_start_vda_request(a, rq);

        esas2r_trace_exit();

        return;
}

static void esas2r_disc_abort(struct esas2r_adapter *a,
                              struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;

        esas2r_trace_enter();

        /* abort the current discovery */

        dc->state = DCS_DISC_DONE;

        esas2r_trace_exit();
}

static bool esas2r_disc_block_dev_scan(struct esas2r_adapter *a,
                                       struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        bool rslt;

        esas2r_trace_enter();

        esas2r_rq_init_request(rq, a);

        esas2r_build_mgt_req(a,
                             rq,
                             VDAMGT_DEV_SCAN,
                             0,
                             0,
                             0,
                             NULL);

        rq->comp_cb = esas2r_disc_block_dev_scan_cb;

        rq->timeout = 30000;
        rq->interrupt_cx = dc;

        rslt = esas2r_disc_start_request(a, rq);

        esas2r_trace_exit();

        return rslt;
}

static void esas2r_disc_block_dev_scan_cb(struct esas2r_adapter *a,
                                          struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        unsigned long flags;

        esas2r_trace_enter();

        spin_lock_irqsave(&a->mem_lock, flags);

        if (rq->req_stat == RS_SUCCESS)
                dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;

        dc->state = DCS_RAID_GRP_INFO;
        dc->raid_grp_ix = 0;

        esas2r_rq_destroy_request(rq, a);

        /* continue discovery if it's interrupt driven */

        if (!(dc->flags & DCF_POLLED))
                esas2r_disc_continue(a, rq);

        spin_unlock_irqrestore(&a->mem_lock, flags);

        esas2r_trace_exit();
}

static bool esas2r_disc_raid_grp_info(struct esas2r_adapter *a,
                                      struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        bool rslt;
        struct atto_vda_grp_info *grpinfo;

        esas2r_trace_enter();

        esas2r_trace("raid_group_idx: %d", dc->raid_grp_ix);

        if (dc->raid_grp_ix >= VDA_MAX_RAID_GROUPS) {
                dc->state = DCS_DISC_DONE;

                esas2r_trace_exit();

                return false;
        }

        esas2r_rq_init_request(rq, a);

        grpinfo = &rq->vda_rsp_data->mgt_data.data.grp_info;

        memset(grpinfo, 0, sizeof(struct atto_vda_grp_info));

        esas2r_build_mgt_req(a,
                             rq,
                             VDAMGT_GRP_INFO,
                             dc->scan_gen,
                             0,
                             sizeof(struct atto_vda_grp_info),
                             NULL);

        grpinfo->grp_index = dc->raid_grp_ix;

        rq->comp_cb = esas2r_disc_raid_grp_info_cb;

        rq->interrupt_cx = dc;

        rslt = esas2r_disc_start_request(a, rq);

        esas2r_trace_exit();

        return rslt;
}

static void esas2r_disc_raid_grp_info_cb(struct esas2r_adapter *a,
                                         struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        unsigned long flags;
        struct atto_vda_grp_info *grpinfo;

        esas2r_trace_enter();

        spin_lock_irqsave(&a->mem_lock, flags);

        if (rq->req_stat == RS_SCAN_GEN) {
                dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
                dc->raid_grp_ix = 0;
                goto done;
        }

        if (rq->req_stat == RS_SUCCESS) {
                grpinfo = &rq->vda_rsp_data->mgt_data.data.grp_info;

                if (grpinfo->status != VDA_GRP_STAT_ONLINE
                    && grpinfo->status != VDA_GRP_STAT_DEGRADED) {
                        /* go to the next group. */

                        dc->raid_grp_ix++;
                } else {
                        memcpy(&dc->raid_grp_name[0],
                               &grpinfo->grp_name[0],
                               sizeof(grpinfo->grp_name));

                        dc->interleave = le32_to_cpu(grpinfo->interleave);
                        dc->block_size = le32_to_cpu(grpinfo->block_size);

                        dc->state = DCS_PART_INFO;
                        dc->part_num = 0;
                }
        } else {
                if (!(rq->req_stat == RS_GRP_INVALID)) {
                        esas2r_log(ESAS2R_LOG_WARN,
                                   "A request for RAID group info failed - "
                                   "returned with %x",
                                   rq->req_stat);
                }

                dc->dev_ix = 0;
                dc->state = DCS_PT_DEV_INFO;
        }

done:

        esas2r_rq_destroy_request(rq, a);

        /* continue discovery if it's interrupt driven */

        if (!(dc->flags & DCF_POLLED))
                esas2r_disc_continue(a, rq);

        spin_unlock_irqrestore(&a->mem_lock, flags);

        esas2r_trace_exit();
}

static bool esas2r_disc_part_info(struct esas2r_adapter *a,
                                  struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        bool rslt;
        struct atto_vdapart_info *partinfo;

        esas2r_trace_enter();

        esas2r_trace("part_num: %d", dc->part_num);

        if (dc->part_num >= VDA_MAX_PARTITIONS) {
                dc->state = DCS_RAID_GRP_INFO;
                dc->raid_grp_ix++;

                esas2r_trace_exit();

                return false;
        }

        esas2r_rq_init_request(rq, a);

        partinfo = &rq->vda_rsp_data->mgt_data.data.part_info;

        memset(partinfo, 0, sizeof(struct atto_vdapart_info));

        esas2r_build_mgt_req(a,
                             rq,
                             VDAMGT_PART_INFO,
                             dc->scan_gen,
                             0,
                             sizeof(struct atto_vdapart_info),
                             NULL);

        partinfo->part_no = dc->part_num;

        memcpy(&partinfo->grp_name[0],
               &dc->raid_grp_name[0],
               sizeof(partinfo->grp_name));

        rq->comp_cb = esas2r_disc_part_info_cb;

        rq->interrupt_cx = dc;

        rslt = esas2r_disc_start_request(a, rq);

        esas2r_trace_exit();

        return rslt;
}

static void esas2r_disc_part_info_cb(struct esas2r_adapter *a,
                                     struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        unsigned long flags;
        struct atto_vdapart_info *partinfo;

        esas2r_trace_enter();

        spin_lock_irqsave(&a->mem_lock, flags);

        if (rq->req_stat == RS_SCAN_GEN) {
                dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
                dc->raid_grp_ix = 0;
                dc->state = DCS_RAID_GRP_INFO;
        } else if (rq->req_stat == RS_SUCCESS) {
                partinfo = &rq->vda_rsp_data->mgt_data.data.part_info;

                dc->part_num = partinfo->part_no;

                dc->curr_virt_id = le16_to_cpu(partinfo->target_id);

                esas2r_targ_db_add_raid(a, dc);

                dc->part_num++;
        } else {
                if (!(rq->req_stat == RS_PART_LAST)) {
                        esas2r_log(ESAS2R_LOG_WARN,
                                   "A request for RAID group partition info "
                                   "failed - status:%d", rq->req_stat);
                }

                dc->state = DCS_RAID_GRP_INFO;
                dc->raid_grp_ix++;
        }

        esas2r_rq_destroy_request(rq, a);

        /* continue discovery if it's interrupt driven */

        if (!(dc->flags & DCF_POLLED))
                esas2r_disc_continue(a, rq);

        spin_unlock_irqrestore(&a->mem_lock, flags);

        esas2r_trace_exit();
}

static bool esas2r_disc_passthru_dev_info(struct esas2r_adapter *a,
                                          struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        bool rslt;
        struct atto_vda_devinfo *devinfo;

        esas2r_trace_enter();

        esas2r_trace("dev_ix: %d", dc->dev_ix);

        esas2r_rq_init_request(rq, a);

        devinfo = &rq->vda_rsp_data->mgt_data.data.dev_info;

        memset(devinfo, 0, sizeof(struct atto_vda_devinfo));

        esas2r_build_mgt_req(a,
                             rq,
                             VDAMGT_DEV_PT_INFO,
                             dc->scan_gen,
                             dc->dev_ix,
                             sizeof(struct atto_vda_devinfo),
                             NULL);

        rq->comp_cb = esas2r_disc_passthru_dev_info_cb;

        rq->interrupt_cx = dc;

        rslt = esas2r_disc_start_request(a, rq);

        esas2r_trace_exit();

        return rslt;
}

static void esas2r_disc_passthru_dev_info_cb(struct esas2r_adapter *a,
                                             struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        unsigned long flags;
        struct atto_vda_devinfo *devinfo;

        esas2r_trace_enter();

        spin_lock_irqsave(&a->mem_lock, flags);

        if (rq->req_stat == RS_SCAN_GEN) {
                dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
                dc->dev_ix = 0;
                dc->state = DCS_PT_DEV_INFO;
        } else if (rq->req_stat == RS_SUCCESS) {
                devinfo = &rq->vda_rsp_data->mgt_data.data.dev_info;

                dc->dev_ix = le16_to_cpu(rq->func_rsp.mgt_rsp.dev_index);

                dc->curr_virt_id = le16_to_cpu(devinfo->target_id);

                if (le16_to_cpu(devinfo->features) & VDADEVFEAT_PHYS_ID) {
                        dc->curr_phys_id =
                                le16_to_cpu(devinfo->phys_target_id);
                        dc->dev_addr_type = ATTO_GDA_AT_PORT;
                        dc->state = DCS_PT_DEV_ADDR;

                        esas2r_trace("curr_virt_id: %d", dc->curr_virt_id);
                        esas2r_trace("curr_phys_id: %d", dc->curr_phys_id);
                } else {
                        dc->dev_ix++;
                }
        } else {
                if (!(rq->req_stat == RS_DEV_INVALID)) {
                        esas2r_log(ESAS2R_LOG_WARN,
                                   "A request for device information failed - "
                                   "status:%d", rq->req_stat);
                }

                dc->state = DCS_DISC_DONE;
        }

        esas2r_rq_destroy_request(rq, a);

        /* continue discovery if it's interrupt driven */

        if (!(dc->flags & DCF_POLLED))
                esas2r_disc_continue(a, rq);

        spin_unlock_irqrestore(&a->mem_lock, flags);

        esas2r_trace_exit();
}

static bool esas2r_disc_passthru_dev_addr(struct esas2r_adapter *a,
                                          struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        bool rslt;
        struct atto_ioctl *hi;
        struct esas2r_sg_context sgc;

        esas2r_trace_enter();

        esas2r_rq_init_request(rq, a);

        /* format the request. */

        sgc.cur_offset = NULL;
        sgc.get_phys_addr = (PGETPHYSADDR)esas2r_disc_get_phys_addr;
        sgc.length = offsetof(struct atto_ioctl, data)
                     + sizeof(struct atto_hba_get_device_address);

        esas2r_sgc_init(&sgc, a, rq, rq->vrq->ioctl.sge);

        esas2r_build_ioctl_req(a, rq, sgc.length, VDA_IOCTL_HBA);

        if (!esas2r_build_sg_list(a, rq, &sgc)) {
                esas2r_rq_destroy_request(rq, a);

                esas2r_trace_exit();

                return false;
        }

        rq->comp_cb = esas2r_disc_passthru_dev_addr_cb;

        rq->interrupt_cx = dc;

        /* format the IOCTL data. */

        hi = (struct atto_ioctl *)a->disc_buffer;

        memset(a->disc_buffer, 0, ESAS2R_DISC_BUF_LEN);

        hi->version = ATTO_VER_GET_DEV_ADDR0;
        hi->function = ATTO_FUNC_GET_DEV_ADDR;
        hi->flags = HBAF_TUNNEL;

        hi->data.get_dev_addr.target_id = le32_to_cpu(dc->curr_phys_id);
        hi->data.get_dev_addr.addr_type = dc->dev_addr_type;

        /* start it up. */

        rslt = esas2r_disc_start_request(a, rq);

        esas2r_trace_exit();

        return rslt;
}

static void esas2r_disc_passthru_dev_addr_cb(struct esas2r_adapter *a,
                                             struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        struct esas2r_target *t = NULL;
        unsigned long flags;
        struct atto_ioctl *hi;
        u16 addrlen;

        esas2r_trace_enter();

        spin_lock_irqsave(&a->mem_lock, flags);

        hi = (struct atto_ioctl *)a->disc_buffer;

        if (rq->req_stat == RS_SUCCESS
            && hi->status == ATTO_STS_SUCCESS) {
                addrlen = le16_to_cpu(hi->data.get_dev_addr.addr_len);

                if (dc->dev_addr_type == ATTO_GDA_AT_PORT) {
                        if (addrlen == sizeof(u64))
                                memcpy(&dc->sas_addr,
                                       &hi->data.get_dev_addr.address[0],
                                       addrlen);
                        else
                                memset(&dc->sas_addr, 0, sizeof(dc->sas_addr));

                        /* Get the unique identifier. */
                        dc->dev_addr_type = ATTO_GDA_AT_UNIQUE;

                        goto next_dev_addr;
                } else {
                        /* Add the pass through target. */
                        if (HIBYTE(addrlen) == 0) {
                                t = esas2r_targ_db_add_pthru(a,
                                                             dc,
                                                             &hi->data.
                                                             get_dev_addr.
                                                             address[0],
                                                             (u8)hi->data.
                                                             get_dev_addr.
                                                             addr_len);

                                if (t)
                                        memcpy(&t->sas_addr, &dc->sas_addr,
                                               sizeof(t->sas_addr));
                        } else {
                                /* getting the back end data failed */

                                esas2r_log(ESAS2R_LOG_WARN,
                                           "an error occurred retrieving the "
                                           "back end data (%s:%d)",
                                           __func__,
                                           __LINE__);
                        }
                }
        } else {
                /* getting the back end data failed */

                esas2r_log(ESAS2R_LOG_WARN,
                           "an error occurred retrieving the back end data - "

                           "rq->req_stat:%d hi->status:%d",
                           rq->req_stat, hi->status);
        }

        /* proceed to the next device. */

        if (dc->flags & DCF_DEV_SCAN) {
                dc->dev_ix++;
                dc->state = DCS_PT_DEV_INFO;
        } else if (dc->flags & DCF_DEV_CHANGE) {
                dc->curr_targ++;
                dc->state = DCS_DEV_ADD;
        } else {
                esas2r_bugon();
        }

next_dev_addr:
        esas2r_rq_destroy_request(rq, a);

        /* continue discovery if it's interrupt driven */

        if (!(dc->flags & DCF_POLLED))
                esas2r_disc_continue(a, rq);

        spin_unlock_irqrestore(&a->mem_lock, flags);

        esas2r_trace_exit();
}

static u32 esas2r_disc_get_phys_addr(struct esas2r_sg_context *sgc, u64 *addr)
{
        struct esas2r_adapter *a = sgc->adapter;

        if (sgc->length > ESAS2R_DISC_BUF_LEN)
                esas2r_bugon();

        *addr = a->uncached_phys
                + (u64)((u8 *)a->disc_buffer - a->uncached);

        return sgc->length;
}

static bool esas2r_disc_dev_remove(struct esas2r_adapter *a,
                                   struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        struct esas2r_target *t;
        struct esas2r_target *t2;

        esas2r_trace_enter();

        /* process removals. */

        for (t = a->targetdb; t < a->targetdb_end; t++) {
                if (t->new_target_state != TS_NOT_PRESENT)
                        continue;

                t->new_target_state = TS_INVALID;

                /* remove the right target! */

                t2 =
                        esas2r_targ_db_find_by_virt_id(a,
                                                       esas2r_targ_get_id(t,
                                                                          a));

                if (t2)
                        esas2r_targ_db_remove(a, t2);
        }

        /* removals complete.  process arrivals. */

        dc->state = DCS_DEV_ADD;
        dc->curr_targ = a->targetdb;

        esas2r_trace_exit();

        return false;
}

static bool esas2r_disc_dev_add(struct esas2r_adapter *a,
                                struct esas2r_request *rq)
{
        struct esas2r_disc_context *dc =
                (struct esas2r_disc_context *)rq->interrupt_cx;
        struct esas2r_target *t = dc->curr_targ;

        if (t >= a->targetdb_end) {
                /* done processing state changes. */

                dc->state = DCS_DISC_DONE;
        } else if (t->new_target_state == TS_PRESENT) {
                struct atto_vda_ae_lu *luevt = &t->lu_event;

                esas2r_trace_enter();

                /* clear this now in case more events come in. */

                t->new_target_state = TS_INVALID;

                /* setup the discovery context for adding this device. */

                dc->curr_virt_id = esas2r_targ_get_id(t, a);

                if ((luevt->hdr.bylength >= offsetof(struct atto_vda_ae_lu, id)
                     + sizeof(struct atto_vda_ae_lu_tgt_lun_raid))
                    && !(luevt->dwevent & VDAAE_LU_PASSTHROUGH)) {
                        dc->block_size = luevt->id.tgtlun_raid.dwblock_size;
                        dc->interleave = luevt->id.tgtlun_raid.dwinterleave;
                } else {
                        dc->block_size = 0;
                        dc->interleave = 0;
                }

                /* determine the device type being added. */

                if (luevt->dwevent & VDAAE_LU_PASSTHROUGH) {
                        if (luevt->dwevent & VDAAE_LU_PHYS_ID) {
                                dc->state = DCS_PT_DEV_ADDR;
                                dc->dev_addr_type = ATTO_GDA_AT_PORT;
                                dc->curr_phys_id = luevt->wphys_target_id;
                        } else {
                                esas2r_log(ESAS2R_LOG_WARN,
                                           "luevt->dwevent does not have the "
                                           "VDAAE_LU_PHYS_ID bit set (%s:%d)",
                                           __func__, __LINE__);
                        }
                } else {
                        dc->raid_grp_name[0] = 0;

                        esas2r_targ_db_add_raid(a, dc);
                }

                esas2r_trace("curr_virt_id: %d", dc->curr_virt_id);
                esas2r_trace("curr_phys_id: %d", dc->curr_phys_id);
                esas2r_trace("dwevent: %d", luevt->dwevent);

                esas2r_trace_exit();
        }

        if (dc->state == DCS_DEV_ADD) {
                /* go to the next device. */

                dc->curr_targ++;
        }

        return false;
}

/*
 * When discovery is done, find all requests on defer queue and
 * test if they need to be modified. If a target is no longer present
 * then complete the request with RS_SEL. Otherwise, update the
 * target_id since after a hibernate it can be a different value.
 * VDA does not make passthrough target IDs persistent.
 */
static void esas2r_disc_fix_curr_requests(struct esas2r_adapter *a)
{
        unsigned long flags;
        struct esas2r_target *t;
        struct esas2r_request *rq;
        struct list_head *element;

        /* update virt_targ_id in any outstanding esas2r_requests  */

        spin_lock_irqsave(&a->queue_lock, flags);

        list_for_each(element, &a->defer_list) {
                rq = list_entry(element, struct esas2r_request, req_list);
                if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
                        t = a->targetdb + rq->target_id;

                        if (t->target_state == TS_PRESENT)
                                rq->vrq->scsi.target_id = le16_to_cpu(
                                        t->virt_targ_id);
                        else
                                rq->req_stat = RS_SEL;
                }

        }

        spin_unlock_irqrestore(&a->queue_lock, flags);
}