/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
 */

#include <sys/sdt.h>
#include "cpqary3.h"

/*
 * Local Functions Definitions
 */

int cpqary3_target_geometry(struct scsi_address *);
int8_t cpqary3_detect_target_geometry(cpqary3_t *);

/*
 * Function     :       cpqary3_read_conf_file
 * Description  :       This routine reads the driver configuration file.
 * Called By    :       cpqary3_attach()
 * Parameters   :       device-information pointer, per_controller
 * Calls        :       None
 * Return Values:       None
 */
void
cpqary3_read_conf_file(dev_info_t *dip, cpqary3_t *cpqary3p)
{
        char            *ptr;

        cpqary3p->noe_support = 0;

        /*
         * Plugin the code necessary to read from driver's conf file.
         * As of now, we are not interested in reading the onf file
         * for any purpose.
         *
         * eg. :
         *
         * retvalue = ddi_getprop(DDI_DEV_T_NONE, dip, DDI_PROP_DONTPASS,
         *      "cpqary3_online_debug", -1);
         */

        /*
         *  We are calling ddi_prop_lookup_string
         *  which gets the property value, which is passed at
         *  the grub menu. If the user wants to use the older
         *  target mapping algorithm,(prior to 1.80)at the grub menu
         *  "cpqary3_tgtmap=off" should be entered. if this
         *  string is entered, then we will set the
         *  value of the variable legacy_mapping to one, which
         *  will be used in
         *  cpqary3_detect_target_geometry()
         *  and cpqary3_probe4LVs(), to decide on the
         *  mapping algorithm
         */

        if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
            "cpqary3_tgtmap", &ptr) == DDI_PROP_SUCCESS) {
                if (strcmp("off", ptr) == 0) {
                        cpqary3p->legacy_mapping = 1;
                }
                ddi_prop_free(ptr);
        }

        if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
            "cpqary3_noesupport", &ptr) == DDI_PROP_SUCCESS) {
                if (strcmp("on", ptr) == 0) {
                        cpqary3p->noe_support = 1;
                }
                if (strcmp("off", ptr) == 0) {
                        cpqary3p->noe_support = 0;
                }
                ddi_prop_free(ptr);
        }
}

/*
 * Function     :       cpqary3_tick_hdlr
 * Description  :       This routine is called once in 60 seconds to detect any
 *                      command that is pending with the controller and has
 *                      timed out.
 *                      Once invoked, it re-initializes itself such that it is
 *                      invoked after an interval of 60 seconds.
 * Called By    :       kernel
 * Parameters   :       per_controller
 * Calls        :       None
 * Return Values:       None
 */
void
cpqary3_tick_hdlr(void *arg)
{
        clock_t                 cpqary3_lbolt;
        clock_t                 cpqary3_ticks;
        cpqary3_t               *ctlr;
        cpqary3_pkt_t           *pktp;
        struct scsi_pkt         *scsi_pktp;
        cpqary3_cmdpvt_t        *local;
        volatile CfgTable_t     *ctp;
        uint32_t                i;
        uint32_t                no_cmds = 0;

        /*
         * The per-controller shall be passed as argument.
         * Read the HeartBeat of the controller.
         * if the current heartbeat is the same as the one recorded earlier,
         * the f/w has locked up!!!
         */

        if (NULL == (ctlr = (cpqary3_t *)arg))
                return;

        ctp = (CfgTable_t *)ctlr->ct;

        /* CONTROLLER_LOCKUP */
        if (ctlr->heartbeat == DDI_GET32(ctlr, &ctp->HeartBeat)) {
                if (ctlr->lockup_logged == CPQARY3_FALSE) {
                        cmn_err(CE_WARN, "CPQary3 : "
                            "%s HBA firmware Locked !!!", ctlr->hba_name);
                        cmn_err(CE_WARN, "CPQary3 : "
                            "Please reboot the system");
                        cpqary3_intr_onoff(ctlr, CPQARY3_INTR_DISABLE);
                        if (ctlr->host_support & 0x4)
                                cpqary3_lockup_intr_onoff(ctlr,
                                    CPQARY3_LOCKUP_INTR_DISABLE);
                        ctlr->controller_lockup = CPQARY3_TRUE;
                        ctlr->lockup_logged = CPQARY3_TRUE;
                }
        }
        /* CONTROLLER_LOCKUP */
        no_cmds  = (uint32_t)((ctlr->ctlr_maxcmds / 3) *
            NO_OF_CMDLIST_IN_A_BLK);
        mutex_enter(&ctlr->sw_mutex);

        for (i = 0; i < no_cmds; i++) {
                local = &ctlr->cmdmemlistp->pool[i];
                ASSERT(local != NULL);
                pktp = MEM2PVTPKT(local);

                if (!pktp)
                        continue;

                if ((local->cmdpvt_flag == CPQARY3_TIMEOUT) ||
                    (local->cmdpvt_flag == CPQARY3_RESET)) {
                        continue;
                }

                if (local->occupied == CPQARY3_OCCUPIED) {
                        scsi_pktp = pktp->scsi_cmd_pkt;
                        cpqary3_lbolt = ddi_get_lbolt();
                        if ((scsi_pktp) && (scsi_pktp->pkt_time)) {
                                cpqary3_ticks = cpqary3_lbolt -
                                    pktp->cmd_start_time;

                                if ((drv_hztousec(cpqary3_ticks)/1000000) >
                                    scsi_pktp->pkt_time) {
                                        scsi_pktp->pkt_reason = CMD_TIMEOUT;
                                        scsi_pktp->pkt_statistics =
                                            STAT_TIMEOUT;
                                        scsi_pktp->pkt_state = STATE_GOT_BUS |
                                            STATE_GOT_TARGET | STATE_SENT_CMD;
                                        local->cmdpvt_flag = CPQARY3_TIMEOUT;

                                        /* This should always be the case */
                                        if (scsi_pktp->pkt_comp) {
                                                mutex_exit(&ctlr->sw_mutex);
                                                (*scsi_pktp->pkt_comp)
                                                    (scsi_pktp);
                                                mutex_enter(&ctlr->sw_mutex);
                                                continue;
                                        }
                                }
                        }
                }
        }

        ctlr->heartbeat = DDI_GET32(ctlr, &ctp->HeartBeat);
        mutex_exit(&ctlr->sw_mutex);
        ctlr->tick_tmout_id = timeout(cpqary3_tick_hdlr,
            (caddr_t)ctlr, drv_usectohz(CPQARY3_TICKTMOUT_VALUE));
}

/*
 * Function     :       cpqary3_init_ctlr_resource
 * Description  :       This routine initializes the command list, initializes
 *                      the controller, enables the interrupt.
 * Called By    :       cpqary3_attach()
 * Parameters   :       per_controller
 * Calls        :       cpqary3_init_ctlr(), cpqary3_meminit(),
 *                      cpqary3_intr_onoff(),
 * Return Values:       SUCCESS / FAILURE
 *                      [ Shall return failure if any of the mandatory
 *                      initializations / setup of resources fail ]
 */
uint16_t
cpqary3_init_ctlr_resource(cpqary3_t *ctlr)
{
#ifdef CPQARY3_DEBUG_MEM
        int8_t i = 0;
#endif

        /*
         * Initialize the Controller
         * Alocate Memory Pool for driver supported number of Commands
         * return if not successful
         * Allocate target structure for controller and initialize the same
         * Detect all existing targets and allocate target structure for each
         * Determine geometry for all existing targets
         * Initialize the condition variables
         */

        RETURN_FAILURE_IF_NULL(ctlr);

        if (CPQARY3_FAILURE == cpqary3_init_ctlr(ctlr))
                return ((CPQARY3_FAILURE));

        if (CPQARY3_FAILURE == cpqary3_meminit(ctlr))
                return ((CPQARY3_FAILURE));


#ifdef CPQARY3_DEBUG_MEM
        /*
         * This code is in place to test the memory management of this driver.
         * This block of code allocates and de-allocates memory as many number
         * of times as given in the for loop.
         * After the for loop is executed, it returns a failure, which in turn
         * would result in attach being failed.
         */
        cmn_err(CE_CONT, "CPQary3 : _init_ctlr_resource : Testing memory \n");
        for (i = 0; i < 15; i++) {
                if (CPQARY3_SUCCESS != cpqary3_meminit(ctlr)) {
                        cmn_err(CE_CONT, "CPQary3 : meminit failed : "
                            "attempt %d \n", i);
                        return (CPQARY3_FAILURE);
                }
                cmn_err(CE_CONT,
                    "CPQary3 : INIT successful : attempt %d \n", i);
                cpqary3_memfini(ctlr, CPQARY3_MEMLIST_DONE |
                    CPQARY3_PHYCTGS_DONE | CPQARY3_CMDMEM_DONE);
                cmn_err(CE_CONT,
                    "CPQary3 : FINI successful : attempt %d \n", i);
        }
        return (CPQARY3_FAILURE);
#endif

        ctlr->cpqary3_tgtp[CTLR_SCSI_ID] = MEM_ZALLOC(sizeof (cpqary3_tgt_t));
        if (!(ctlr->cpqary3_tgtp[CTLR_SCSI_ID])) {
                cmn_err(CE_WARN, "CPQary3: Target Initialization Failed");
                cpqary3_memfini(ctlr, CPQARY3_MEMLIST_DONE |
                    CPQARY3_PHYCTGS_DONE | CPQARY3_CMDMEM_DONE);
                return (CPQARY3_FAILURE);
        }
        ctlr->cpqary3_tgtp[CTLR_SCSI_ID]->type = CPQARY3_TARGET_CTLR;

        cpqary3_intr_onoff(ctlr, CPQARY3_INTR_DISABLE);

        /*
         * Initialize all condition variables :
         * for the immediate call back
         * for the disable noe
         * for fulsh cache
         * for probe device
         */

        cv_init(&ctlr->cv_immediate_wait, NULL, CV_DRIVER, NULL);
        cv_init(&ctlr->cv_noe_wait, NULL, CV_DRIVER, NULL);
        cv_init(&ctlr->cv_flushcache_wait, NULL, CV_DRIVER, NULL);
        cv_init(&ctlr->cv_abort_wait, NULL, CV_DRIVER, NULL);
        cv_init(&ctlr->cv_ioctl_wait, NULL, CV_DRIVER, NULL);

        return (CPQARY3_SUCCESS);
}

/*
 * Function     :       cpqary3_target_geometry
 * Description  :       This function returns the geometry for the target.
 * Called By    :       cpqary3_getcap()
 * Parameters   :       Target SCSI address
 * Calls        :       None
 * Return Values:       Device Geometry
 */
int
cpqary3_target_geometry(struct scsi_address *sa)
{
        cpqary3_t       *ctlr = SA2CTLR(sa);
        cpqary3_tgt_t   *tgtp = ctlr->cpqary3_tgtp[SA2TGT(sa)];

        /*
         * The target CHS are stored in the per-target structure
         * during attach time. Use these values
         */
        return ((tgtp->properties.drive.heads << 16) |
            tgtp->properties.drive.sectors);
}

/*
 * Function     :       cpqary3_synccmd_alloc
 * Description  :       This function allocates the DMA buffer for the commands
 * Called By    :       cpqary3_ioctl_send_bmiccmd(),
 *                      cpqary3_ioctl_send_scsicmd()
 *                      cpqary3_send_abortcmd(), cpqary3_flush_cache(),
 *                      cpqary3_probe4LVs(), cpqary3_probe4Tapes(),
 *                      cpqary3_detect_target_geometry()
 * Parameters   :       per_controller, buffer size
 * Calls        :       cpqary3_alloc_phyctgs_mem(), cpqary3_cmdlist_occupy()
 * Return Values:       memp
 */
cpqary3_cmdpvt_t *
cpqary3_synccmd_alloc(cpqary3_t *cpqary3p, size_t bufsz)
{
        cpqary3_private_t       *cmddmah = NULL;
        uint32_t                dmabufpa = 0;   /* XXX 32-bit pa? */
        cpqary3_cmdpvt_t        *memp = NULL;

        /*  first, allocate any necessary dma buffers  */
        if (bufsz > 0) {
                cpqary3_phyctg_t        *dmah = NULL;
                caddr_t                 dmabufva = NULL;

                /* first, allocate the command's dma handle */
                cmddmah = (cpqary3_private_t *)MEM_ZALLOC(sizeof (*cmddmah));
                if (cmddmah == NULL) {
                        cmn_err(CE_WARN, "cpqary3_synccmd_alloc: "
                            "no memory for cmddmah");
                        return (NULL);
                }

                /* next, allocate dma handle */
                dmah = (cpqary3_phyctg_t *)MEM_ZALLOC(sizeof (*dmah));
                if (dmah == NULL) {
                        MEM_SFREE(cmddmah, sizeof (*cmddmah));
                        cmn_err(CE_WARN, "cpqary3_synccmd_alloc: "
                            "no memory for dmah");
                        return (NULL);
                }
                /* now, allocate dma buffer */
                dmabufva = cpqary3_alloc_phyctgs_mem(cpqary3p, bufsz,
                    &dmabufpa, dmah);
                if (dmabufva == NULL) {
                        MEM_SFREE(cmddmah, sizeof (*cmddmah));
                        cmn_err(CE_WARN, "cpqary3_synccmd_alloc: "
                            "no memory for dma buf");
                        return (NULL);
                }
                bzero(dmabufva, bufsz);

                /* attach dma buffer to command dma handle */
                cmddmah->sg = dmabufva;
                cmddmah->phyctgp = dmah;
        }

        /* next, allocate a command packet */
        memp = cpqary3_cmdlist_occupy(cpqary3p);
        if (memp == NULL) {
                if (cmddmah != NULL) {
                        cpqary3_free_phyctgs_mem(cmddmah->phyctgp,
                            CPQARY3_FREE_PHYCTG_MEM);
                        MEM_SFREE(cmddmah, sizeof (*cmddmah));
                }
                cmn_err(CE_WARN, "cpqary3_synccmd_alloc: "
                    "cannot get free command");
                return (NULL);
        }
        memp->cmdpvt_flag = 0;
        memp->cmdlist_memaddr->Header.Tag.drvinfo_n_err =
            CPQARY3_SYNCCMD_SUCCESS;

        /* attach dma resources to command */
        memp->driverdata = cmddmah;
        memp->cmdlist_memaddr->SG[0].Addr = dmabufpa;
        memp->cmdlist_memaddr->SG[0].Len  = (uint32_t)bufsz;

        /* done */
        return (memp);
}

/*
 * Function     :   cpqary3_synccmd_cleanup
 * Description  :   This routine cleans up the command
 * Called By    :   cpqary3_process_pkt(), cpqary3_synccmd_free()
 * Parameters   :   per_command_memory
 * Calls        :   cpqary3_free_phyctgs_mem(), cpqary3_cmdlist_release()
 * Return Values:   none
 */
void
cpqary3_synccmd_cleanup(cpqary3_cmdpvt_t *memp)
{
        /*
         * ordinary users should not call this routine
         * (use cpqary3_synccmd_free() instead).  this is
         * for use ONLY by cpqary3_synccmd_free() and
         * cpqary3_process_pkt().
         */

        if (memp->driverdata != NULL) {
                /* free dma resources */
                cpqary3_free_phyctgs_mem(memp->driverdata->phyctgp,
                    CPQARY3_FREE_PHYCTG_MEM);
                MEM_SFREE(memp->driverdata, sizeof (cpqary3_private_t));
                memp->driverdata = NULL;
        }
        /* release command */
        memp->cmdpvt_flag = 0;
        cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
}

/*
 * Function     :       cpqary3_synccmd_free
 * Description  :       This routine frees the command and the
 *                      associated resources.
 * Called By    :       cpqary3_ioctl_send_bmiccmd(),
 *                      cpqary3_ioctl_send_scsicmd()
 *                      cpqary3_send_abortcmd(), cpqary3_flush_cache(),
 *                      cpqary3_probe4LVs(), cpqary3_probe4Tapes(),
 *                      cpqary3_detect_target_geometry()
 * Parameters   :       per_controller, per_command_memory
 * Calls        :       cpqary3_synccmd_cleanup()
 * Return Values:       NONE
 */
void
cpqary3_synccmd_free(cpqary3_t *cpqary3p, cpqary3_cmdpvt_t *memp)
{
        /*
         * so, the user is done with this command packet.
         * we have three possible scenarios here:
         *
         * 1) the command was never submitted to the controller
         *
         * or
         *
         * 2) the command has completed at the controller and has
         *    been fully processed by the interrupt processing
         *    mechanism and is no longer on the submitted or
         *    retrieve queues.
         *
         * or
         *
         * 3) the command is not yet complete at the controller,
         *    and/or hasn't made it through cpqary3_process_pkt()
         *    yet.
         *
         * For cases (1) and (2), we can go ahead and free the
         * command and the associated resources.  For case (3), we
         * must mark the command as no longer needed, and let
         * cpqary3_process_pkt() clean it up instead.
         */

        mutex_enter(&(cpqary3p->sw_mutex));
        if (memp->cmdpvt_flag == CPQARY3_SYNC_SUBMITTED) {
                /*
                 * command is still pending (case #3 above).
                 * mark the command as abandoned and let
                 * cpqary3_process_pkt() clean it up.
                 */
                memp->cmdpvt_flag = CPQARY3_SYNC_TIMEOUT;
                mutex_exit(&(cpqary3p->sw_mutex));
                return;
        }
        memp->cmdpvt_flag = 0;
        mutex_exit(&(cpqary3p->sw_mutex));

        /*
         * command was either never submitted or has completed
         * (cases #1 and #2 above).  so, clean it up.
         */
        cpqary3_synccmd_cleanup(memp);

        /* done */
        return;

}  /* cpqary3_synccmd_free() */

/*
 * Function     :       cpqary3_synccmd_send
 * Description  :       This routine sends the command to the controller
 * Called By    :       cpqary3_ioctl_send_bmiccmd(),
 *                      cpqary3_ioctl_send_scsicmd()
 *                      cpqary3_send_abortcmd(), cpqary3_flush_cache(),
 *                      cpqary3_probe4LVs(), cpqary3_probe4Tapes(),
 *                      cpqary3_detect_target_geometry()
 * Parameters   :       per_controller, per_command_memory, timeout value,
 *                      flag(wait for reply)
 * Calls        :       cpqary3_submit(), cpqary3_add2submitted_cmdq()
 * Return Values:       SUCCESS / FAILURE
 */
int
cpqary3_synccmd_send(cpqary3_t *cpqary3p, cpqary3_cmdpvt_t *memp,
    clock_t timeoutms, int flags)
{
        clock_t         absto = 0;  /* absolute timeout */
        int             waitsig = 0;
        int             rc = 0;
        kcondvar_t      *cv = 0;

        /*  compute absolute timeout, if necessary  */
        if (timeoutms > 0)
                absto = ddi_get_lbolt() + drv_usectohz(timeoutms * 1000);

        /*  heed signals during wait?  */
        if (flags & CPQARY3_SYNCCMD_SEND_WAITSIG)
                waitsig = 1;

        /*  acquire the sw mutex for our wait  */
        mutex_enter(&(cpqary3p->sw_mutex));

        /*  submit command to controller  */
        mutex_enter(&(cpqary3p->hw_mutex));

        memp->cmdpvt_flag = CPQARY3_SYNC_SUBMITTED;
        memp->cmdlist_memaddr->Header.Tag.drvinfo_n_err =
            CPQARY3_SYNCCMD_SUCCESS;
        if (EIO == cpqary3_submit(cpqary3p, memp->cmdlist_phyaddr)) {
                mutex_exit(&(cpqary3p->hw_mutex));
                mutex_exit(&(cpqary3p->sw_mutex));
                rc = -1;
                return (rc);
        }
        mutex_exit(&(cpqary3p->hw_mutex));

        /*  wait for command completion, timeout, or signal  */
        while (memp->cmdpvt_flag == CPQARY3_SYNC_SUBMITTED) {
                kmutex_t *mt = &(cpqary3p->sw_mutex);

                cv = &(cpqary3p->cv_ioctl_wait);
                /*  wait with the request behavior  */
                if (absto) {
                        clock_t   crc;
                        if (waitsig) {
                                crc = cv_timedwait_sig(cv, mt, absto);
                        } else {
                                crc = cv_timedwait(cv, mt, absto);
                        }
                        if (crc > 0)
                                rc = 0;
                        else
                                rc = (-1);
                } else {
                        if (waitsig) {
                                rc = cv_wait_sig(cv, mt);
                                if (rc > 0)
                                        rc = 0;
                                else
                                        rc = (-1);
                        } else {
                                cv_wait(cv, mt);
                                rc = 0;
                        }
                }


                /*
                 * if our wait was interrupted (timeout),
                 * then break here
                 */
                if (rc) {
                        break;
                }
        }

        /* our wait is done, so release the sw mutex */
        mutex_exit(&(cpqary3p->sw_mutex));

        /* return the results */
        return (rc);
}

/*
 * Function     :       cpqary3_detect_target_geometry
 * Description  :       This function determines the geometry for all
 *                      the existing targets for the controller.
 * Called By    :       cpqary3_tgt_init()
 * Parameters   :       per controller
 * Calls        :       cpqary3_synccmd_alloc(), cpqary3_synccmd_send()
 *                      cpqary3_synccmd_free()
 * Return Values:       SUCCESS / FAILURE
 *                      [ Shall return failure only if Memory constraints exist
 *                      or controller does not respond ]
 */
int8_t
cpqary3_detect_target_geometry(cpqary3_t *ctlr)
{
        int                     i;
        int8_t                  ld_count = 0;
        int8_t                  loop_cnt = 0;
        IdLogDrive              *idlogdrive;
        CommandList_t           *cmdlistp;
        cpqary3_cmdpvt_t        *cpqary3_cmdpvtp;

        RETURN_FAILURE_IF_NULL(ctlr);

        /*
         * Occupy a Command List
         * Allocate Memory for return data
         * If error, RETURN 0.
         * get the Request Block from the CommandList
         * Fill in the Request Packet with the corresponding values
         * Submit the Command and Poll for its completion
         * If success, continue else RETURN 0
         */

        /* Sync Changes */
        cpqary3_cmdpvtp = cpqary3_synccmd_alloc(ctlr, sizeof (IdLogDrive));
        if (cpqary3_cmdpvtp == NULL)
                return (CPQARY3_FAILURE);

        cmdlistp = cpqary3_cmdpvtp->cmdlist_memaddr;
        idlogdrive = (IdLogDrive *)cpqary3_cmdpvtp->driverdata->sg;
        /* Sync Changes */


        /* Update Cmd Header */
        cmdlistp->Header.SGList = 1;
        cmdlistp->Header.SGTotal = 1;
        cmdlistp->Header.Tag.drvinfo_n_err = CPQARY3_SYNCCMD_SUCCESS;

        /* Cmd Reques */
        cmdlistp->Request.CDBLen = CPQARY3_CDBLEN_16;
        cmdlistp->Request.CDB[0] = 0x26;
        cmdlistp->Request.CDB[6] = BMIC_IDENTIFY_LOGICAL_DRIVE;
        cmdlistp->Request.CDB[7] = (sizeof (IdLogDrive) >> 8) & 0xff;
        cmdlistp->Request.CDB[8] = sizeof (IdLogDrive) & 0xff;
        cmdlistp->Request.Type.Type = CISS_TYPE_CMD;
        cmdlistp->Request.Type.Attribute = CISS_ATTR_HEADOFQUEUE;
        cmdlistp->Request.Type.Direction = CISS_XFER_READ;

        /*
         * For all the Targets that exist, issue an IDENTIFY LOGICAL DRIVE.
         * That returns values which includes the dsired Geometry also.
         * Update the Geometry in the per-target structure.
         * NOTE : When the loop is executed for i=controller's SCSI ID, just
         * increament by one so that we are talking to the next logical
         * drive in our per-target structure.
         */

        /*
         * Depending upon the value of the variable legacy_mapping
         * set in cpqary3_attach(),
         * the target mapping algorithm to be used by the driver is decided.
         */

        if (ctlr->legacy_mapping == 1) {
                loop_cnt = ((ctlr->num_of_targets > CTLR_SCSI_ID) ?
                    (ctlr->num_of_targets + 1) : (ctlr->num_of_targets));

                for (i = 0; i < loop_cnt; i++) {
                        if (i == CTLR_SCSI_ID)  /* Go to Next logical target */
                                i++;

                        bzero(idlogdrive, sizeof (IdLogDrive));
                        cmdlistp->Request.CDB[1] =
                            ctlr->cpqary3_tgtp[i]->logical_id;

                        /* Always zero */
                        cmdlistp->Header.LUN.PhysDev.TargetId = 0;

                        /*
                         * Logical volume Id numbering scheme is as follows
                         * 0x00000, 0x00001, ... - for Direct Attached
                         * 0x10000, 0x10001, ... - If 1st Port of HBA is
                         * connected to  MSA20 / MSA500
                         * 0x20000, 0x20001, ... - If 2nd Port of HBA is
                         * connected to MSA20 / MSA500
                         */
                        cmdlistp->Header.LUN.PhysDev.Bus =
                            (ctlr->cpqary3_tgtp[i]->logical_id) >> 16;
                        cmdlistp->Header.LUN.PhysDev.Mode =
                            (cmdlistp->Header.LUN.PhysDev.Bus > 0) ?
                            MASK_PERIPHERIAL_DEV_ADDR : PERIPHERIAL_DEV_ADDR;

                        /*
                         * Submit the command
                         * Poll for its completion
                         * If polling is not successful, something is wrong
                         * with the controler
                         * Return FAILURE (No point in continuing if h/w is
                         * faulty !!!)
                         */

                        /* PERF */
                        cpqary3_cmdpvtp->complete = cpqary3_synccmd_complete;
                        /* PERF */

                        /* Sync Changes */
                        if (cpqary3_synccmd_send(ctlr, cpqary3_cmdpvtp, 90000,
                            CPQARY3_SYNCCMD_SEND_WAITSIG) != 0) {
                                /* Timed out */
                                cpqary3_synccmd_free(ctlr, cpqary3_cmdpvtp);
                                return (CPQARY3_FAILURE);
                        }
                        if ((cpqary3_cmdpvtp->
                            cmdlist_memaddr->Header.Tag.drvinfo_n_err ==
                            CPQARY3_SYNCCMD_FAILURE) &&
                            (cpqary3_cmdpvtp->errorinfop->CommandStatus != 2)) {
                                DTRACE_PROBE1(id_logdrv_fail,
                                    ErrorInfo_t *, cpqary3_cmdpvtp->errorinfop);
                                cpqary3_synccmd_free(ctlr, cpqary3_cmdpvtp);
                                return (CPQARY3_FAILURE);
                        }
                        /* Sync Changes */

                        ctlr->cpqary3_tgtp[i]->properties.drive.heads =
                            idlogdrive->heads;
                        ctlr->cpqary3_tgtp[i]->properties.drive.sectors =
                            idlogdrive->sectors;

                        DTRACE_PROBE2(tgt_geometry_detect,
                            int, i, IdLogDrive *, idlogdrive);
                }
        } else {

                /*
                 * Fix for QXCR1000446657: Logical drives are re numbered
                 * after deleting a Logical drive.
                 * introduced, new variable ld_count, which gets
                 * incremented when the Target ID is found.
                 * And for i=controller's SCSI ID and LDs with holes are found,
                 * we continue talking to
                 * the next logical drive in the per-target structure
                 */

                for (i = 0; ld_count < ctlr->num_of_targets; i++) {
                        if (i == CTLR_SCSI_ID ||
                            ctlr->cpqary3_tgtp[i] == NULL)
                        /*  Go to the Next logical target  */
                        continue;
                        bzero(idlogdrive, sizeof (IdLogDrive));
                        cmdlistp->Request.CDB[1] =
                            ctlr->cpqary3_tgtp[i]->logical_id;
                        /* Always zero */
                        cmdlistp->Header.LUN.PhysDev.TargetId = 0;
                        /*
                         * Logical volume Id numbering scheme is as follows
                         * 0x00000, 0x00001, ... - for Direct Attached
                         * 0x10000, 0x10001, ... - If 1st Port of HBA is
                         * connected to  MSA20 / MSA500
                         * 0x20000, 0x20001, ... - If 2nd Port of HBA is
                         * connected to MSA20 / MSA500
                         */
                        cmdlistp->Header.LUN.PhysDev.Bus =
                            (ctlr->cpqary3_tgtp[i]->logical_id) >> 16;
                        cmdlistp->Header.LUN.PhysDev.Mode =
                            (cmdlistp->Header.LUN.PhysDev.Bus > 0) ?
                            MASK_PERIPHERIAL_DEV_ADDR : PERIPHERIAL_DEV_ADDR;
                        /* PERF */
                        cpqary3_cmdpvtp->complete = cpqary3_synccmd_complete;
                        /* PERF */

                        /*
                         * Submit the command
                         * Poll for its completion
                         * If polling is not successful, something is wrong
                         * with the controler
                         * Return FAILURE (No point in continuing if h/w is
                         * faulty !!!)
                         */

                        /* Sync Changes */
                        if (cpqary3_synccmd_send(ctlr, cpqary3_cmdpvtp, 90000,
                            CPQARY3_SYNCCMD_SEND_WAITSIG) != 0) {
                                /* Timed out */
                                cpqary3_synccmd_free(ctlr, cpqary3_cmdpvtp);
                                return (CPQARY3_FAILURE);
                        }
                        if ((cpqary3_cmdpvtp->
                            cmdlist_memaddr->Header.Tag.drvinfo_n_err ==
                            CPQARY3_SYNCCMD_FAILURE) &&
                            (cpqary3_cmdpvtp->errorinfop->CommandStatus != 2)) {
                                DTRACE_PROBE1(id_logdrv_fail,
                                    ErrorInfo_t *, cpqary3_cmdpvtp->errorinfop);
                                cpqary3_synccmd_free(ctlr, cpqary3_cmdpvtp);
                                return (CPQARY3_FAILURE);
                        }
                        /* Sync Changes */

                        ctlr->cpqary3_tgtp[i]->properties.drive.heads =
                            idlogdrive->heads;
                        ctlr->cpqary3_tgtp[i]->properties.drive.sectors =
                            idlogdrive->sectors;

                        DTRACE_PROBE2(tgt_geometry_detect,
                            int, i, IdLogDrive *, idlogdrive);

                        ld_count++;
                }
        }

        /* Sync Changes */
        cpqary3_synccmd_free(ctlr, cpqary3_cmdpvtp);
        /* Sync Changes */

        return (CPQARY3_SUCCESS);
}