/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 */


/*
 * Direct Attached  disk driver for SPARC machines.
 */

/*
 * Includes, Declarations and Local Data
 */
#include <sys/dada/dada.h>
#include <sys/dkbad.h>
#include <sys/dklabel.h>
#include <sys/dkio.h>
#include <sys/cdio.h>
#include <sys/vtoc.h>
#include <sys/dada/targets/daddef.h>
#include <sys/dada/targets/dadpriv.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/kstat.h>
#include <sys/vtrace.h>
#include <sys/aio_req.h>
#include <sys/note.h>
#include <sys/cmlb.h>

/*
 * Global Error Levels for Error Reporting
 */
int dcd_error_level     = DCD_ERR_RETRYABLE;
/*
 * Local Static Data
 */

static int dcd_io_time          = DCD_IO_TIME;
static int dcd_retry_count      = DCD_RETRY_COUNT;
#ifndef lint
static int dcd_report_pfa = 1;
#endif
static int dcd_rot_delay = 4;
static int dcd_poll_busycnt = DCD_POLL_TIMEOUT;

/*
 * Local Function Prototypes
 */

static int dcdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
static int dcdclose(dev_t dev, int flag, int otyp, cred_t *cred_p);
static int dcdstrategy(struct buf *bp);
static int dcddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
static int dcdioctl(dev_t, int, intptr_t, int, cred_t *, int *);
static int dcdread(dev_t dev, struct uio *uio, cred_t *cred_p);
static int dcdwrite(dev_t dev, struct uio *uio, cred_t *cred_p);
static int dcd_prop_op(dev_t, dev_info_t *, ddi_prop_op_t, int,
    char *, caddr_t, int *);
static int dcdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
static int dcdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);


static void dcd_free_softstate(struct dcd_disk *un, dev_info_t *devi);
static int dcd_doattach(dev_info_t *devi, int (*f)());
static int dcd_validate_geometry(struct dcd_disk *un);
static ddi_devid_t dcd_get_devid(struct dcd_disk *un);
static ddi_devid_t  dcd_create_devid(struct dcd_disk *un);
static int dcd_make_devid_from_serial(struct dcd_disk *un);
static void dcd_validate_model_serial(char *str, int *retlen, int totallen);
static int dcd_read_deviceid(struct dcd_disk *un);
static int dcd_write_deviceid(struct dcd_disk *un);
static int dcd_poll(struct dcd_pkt *pkt);
static char *dcd_rname(int reason);
static void dcd_flush_cache(struct dcd_disk *un);

static int dcd_compute_dk_capacity(struct dcd_device *devp,
    diskaddr_t *capacity);
static int dcd_send_lb_rw_cmd(dev_info_t *devinfo, void *bufaddr,
    diskaddr_t start_block, size_t reqlength, uchar_t cmd);

static void dcdmin(struct buf *bp);

static int dcdioctl_cmd(dev_t, struct udcd_cmd *,
    enum uio_seg, enum uio_seg);

static void dcdstart(struct dcd_disk *un);
static void dcddone_and_mutex_exit(struct dcd_disk *un, struct buf *bp);
static void make_dcd_cmd(struct dcd_disk *un, struct buf *bp, int (*f)());
static void dcdudcdmin(struct buf *bp);

static int dcdrunout(caddr_t);
static int dcd_check_wp(dev_t dev);
static int dcd_unit_ready(dev_t dev);
static void dcd_handle_tran_busy(struct buf *bp, struct diskhd *dp,
    struct dcd_disk *un);
static void dcdintr(struct dcd_pkt *pkt);
static int dcd_handle_incomplete(struct dcd_disk *un, struct buf *bp);
static void dcd_offline(struct dcd_disk *un, int bechatty);
static int dcd_ready_and_valid(dev_t dev, struct dcd_disk *un);
static void dcd_reset_disk(struct dcd_disk *un, struct dcd_pkt *pkt);
static void dcd_translate(struct dadkio_status32 *statp, struct udcd_cmd *cmdp);
static int dcdflushdone(struct buf *bp);

/* Function prototypes for cmlb */

static int dcd_lb_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
    diskaddr_t start_block, size_t reqlength, void *tg_cookie);

static int dcd_lb_getphygeom(dev_info_t *devi, cmlb_geom_t *phygeomp);
static int dcd_lb_getinfo(dev_info_t *devi, int cmd, void *arg,
    void *tg_cookie);


static cmlb_tg_ops_t dcd_lb_ops = {
        TG_DK_OPS_VERSION_1,
        dcd_lb_rdwr,
        dcd_lb_getinfo
};

/*
 * Error and Logging Functions
 */
#ifndef lint
static void clean_print(dev_info_t *dev, char *label, uint_t level,
    char *title, char *data, int len);
static void dcdrestart(void *arg);
#endif /* lint */

static int dcd_check_error(struct dcd_disk *un, struct buf *bp);

/*
 * Error statistics create/update functions
 */
static int dcd_create_errstats(struct dcd_disk *, int);



/*PRINTFLIKE4*/
extern void dcd_log(dev_info_t *, char *, uint_t, const char *, ...)
    __KPRINTFLIKE(4);
extern void makecommand(struct dcd_pkt *, int, uchar_t, uint32_t,
    uchar_t, uint32_t, uchar_t, uchar_t);


/*
 * Configuration Routines
 */
static int dcdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
    void **result);
static int dcdprobe(dev_info_t *devi);
static int dcdattach(dev_info_t *devi, ddi_attach_cmd_t cmd);
static int dcddetach(dev_info_t *devi, ddi_detach_cmd_t cmd);
static int dcdreset(dev_info_t *dip, ddi_reset_cmd_t cmd);
static int dcd_dr_detach(dev_info_t *devi);
static int dcdpower(dev_info_t *devi, int component, int level);

static void *dcd_state;
static int dcd_max_instance;
static char *dcd_label = "dad";

static char *diskokay = "disk okay\n";

#if DEBUG || lint
#define DCDDEBUG
#endif

int dcd_test_flag = 0;
/*
 * Debugging macros
 */
#ifdef  DCDDEBUG
static int dcddebug = 0;
#define DEBUGGING       (dcddebug > 1)
#define DAD_DEBUG       if (dcddebug == 1) dcd_log
#define DAD_DEBUG2      if (dcddebug > 1) dcd_log
#else   /* DCDDEBUG */
#define dcddebug                (0)
#define DEBUGGING       (0)
#define DAD_DEBUG       if (0) dcd_log
#define DAD_DEBUG2      if (0) dcd_log
#endif

/*
 * we use pkt_private area for storing bp and retry_count
 * XXX: Really is this usefull.
 */
struct dcd_pkt_private {
        struct buf      *dcdpp_bp;
        short            dcdpp_retry_count;
        short            dcdpp_victim_retry_count;
};


_NOTE(SCHEME_PROTECTS_DATA("Unique per pkt", dcd_pkt_private buf))

#define PP_LEN  (sizeof (struct dcd_pkt_private))

#define PKT_SET_BP(pkt, bp)     \
        ((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_bp = bp
#define PKT_GET_BP(pkt) \
        (((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_bp)


#define PKT_SET_RETRY_CNT(pkt, n) \
        ((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_retry_count = n

#define PKT_GET_RETRY_CNT(pkt) \
        (((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_retry_count)

#define PKT_INCR_RETRY_CNT(pkt, n) \
        ((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_retry_count += n

#define PKT_SET_VICTIM_RETRY_CNT(pkt, n) \
        ((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_victim_retry_count \
                        = n

#define PKT_GET_VICTIM_RETRY_CNT(pkt) \
        (((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_victim_retry_count)
#define PKT_INCR_VICTIM_RETRY_CNT(pkt, n) \
        ((struct dcd_pkt_private *)pkt->pkt_private)->dcdpp_victim_retry_count \
                        += n

#define DISK_NOT_READY_RETRY_COUNT      (dcd_retry_count / 2)


/*
 * Urk!
 */
#define SET_BP_ERROR(bp, err)   \
        bioerror(bp, err);

#define IOSP                    KSTAT_IO_PTR(un->un_stats)
#define IO_PARTITION_STATS      un->un_pstats[DCDPART(bp->b_edev)]
#define IOSP_PARTITION          KSTAT_IO_PTR(IO_PARTITION_STATS)

#define DCD_DO_KSTATS(un, kstat_function, bp) \
        ASSERT(mutex_owned(DCD_MUTEX)); \
        if (bp != un->un_sbufp) { \
                if (un->un_stats) { \
                        kstat_function(IOSP); \
                } \
                if (IO_PARTITION_STATS) { \
                        kstat_function(IOSP_PARTITION); \
                } \
        }

#define DCD_DO_ERRSTATS(un, x) \
        if (un->un_errstats) { \
                struct dcd_errstats *dtp; \
                dtp = (struct dcd_errstats *)un->un_errstats->ks_data; \
                dtp->x.value.ui32++; \
        }

#define GET_SOFT_STATE(dev)                                             \
        struct dcd_disk *un;                                    \
        int instance, part;                                     \
        minor_t minor = getminor(dev);                          \
                                                                        \
        part = minor & DCDPART_MASK;                                    \
        instance = minor >> DCDUNIT_SHIFT;                              \
        if ((un = ddi_get_soft_state(dcd_state, instance)) == NULL)     \
                return (ENXIO);

#define LOGICAL_BLOCK_ALIGN(blkno, blknoshift) \
                (((blkno) & ((1 << (blknoshift)) - 1)) == 0)

/*
 * After the following number of sectors, the cylinder number spills over
 * 0xFFFF if sectors = 63 and heads = 16.
 */
#define NUM_SECTORS_32G 0x3EFFC10

/*
 * Configuration Data
 */

/*
 * Device driver ops vector
 */

static struct cb_ops dcd_cb_ops = {
        dcdopen,                /* open */
        dcdclose,               /* close */
        dcdstrategy,            /* strategy */
        nodev,                  /* print */
        dcddump,                /* dump */
        dcdread,                /* read */
        dcdwrite,               /* write */
        dcdioctl,               /* ioctl */
        nodev,                  /* devmap */
        nodev,                  /* mmap */
        nodev,                  /* segmap */
        nochpoll,               /* poll */
        dcd_prop_op,            /* cb_prop_op */
        0,                      /* streamtab  */
        D_64BIT | D_MP | D_NEW, /* Driver compatibility flag */
        CB_REV,                 /* cb_rev */
        dcdaread,               /* async I/O read entry point */
        dcdawrite               /* async I/O write entry point */
};

static struct dev_ops dcd_ops = {
        DEVO_REV,               /* devo_rev, */
        0,                      /* refcnt  */
        dcdinfo,                /* info */
        nulldev,                /* identify */
        dcdprobe,               /* probe */
        dcdattach,              /* attach */
        dcddetach,              /* detach */
        dcdreset,               /* reset */
        &dcd_cb_ops,            /* driver operations */
        (struct bus_ops *)0,    /* bus operations */
        dcdpower,               /* power */
        ddi_quiesce_not_supported,      /* devo_quiesce */
};


/*
 * This is the loadable module wrapper.
 */
#include <sys/modctl.h>

static struct modldrv modldrv = {
        &mod_driverops,         /* Type of module. This one is a driver */
        "DAD Disk Driver",      /* Name of the module. */
        &dcd_ops,       /* driver ops */
};



static struct modlinkage modlinkage = {
        MODREV_1, &modldrv, NULL
};

/*
 * the dcd_attach_mutex only protects dcd_max_instance in multi-threaded
 * attach situations
 */
static kmutex_t dcd_attach_mutex;

int
_init(void)
{
        int e;

        if ((e = ddi_soft_state_init(&dcd_state, sizeof (struct dcd_disk),
            DCD_MAXUNIT)) != 0)
                return (e);

        mutex_init(&dcd_attach_mutex, NULL, MUTEX_DRIVER, NULL);
        e = mod_install(&modlinkage);
        if (e != 0) {
                mutex_destroy(&dcd_attach_mutex);
                ddi_soft_state_fini(&dcd_state);
                return (e);
        }

        return (e);
}

int
_fini(void)
{
        int e;

        if ((e = mod_remove(&modlinkage)) != 0)
                return (e);

        ddi_soft_state_fini(&dcd_state);
        mutex_destroy(&dcd_attach_mutex);

        return (e);
}

int
_info(struct modinfo *modinfop)
{

        return (mod_info(&modlinkage, modinfop));
}

static int
dcdprobe(dev_info_t *devi)
{
        struct dcd_device *devp;
        int rval = DDI_PROBE_PARTIAL;
        int instance;

        devp = ddi_get_driver_private(devi);
        instance = ddi_get_instance(devi);

        /*
         * Keep a count of how many disks (ie. highest instance no) we have
         * XXX currently not used but maybe useful later again
         */
        mutex_enter(&dcd_attach_mutex);
        if (instance > dcd_max_instance)
                dcd_max_instance = instance;
        mutex_exit(&dcd_attach_mutex);

        DAD_DEBUG2(devp->dcd_dev, dcd_label, DCD_DEBUG, "dcdprobe:\n");

        if (ddi_get_soft_state(dcd_state, instance) != NULL)
                return (DDI_PROBE_PARTIAL);

        /*
         * Turn around and call utility probe routine
         * to see whether we actually have a disk at
         */

        DAD_DEBUG2(devp->dcd_dev, dcd_label, DCD_DEBUG,
            "dcdprobe: %x\n", dcd_probe(devp, NULL_FUNC));

        switch (dcd_probe(devp, NULL_FUNC)) {
        default:
        case DCDPROBE_NORESP:
        case DCDPROBE_NONCCS:
        case DCDPROBE_NOMEM:
        case DCDPROBE_FAILURE:
        case DCDPROBE_BUSY:
                break;

        case DCDPROBE_EXISTS:
                /*
                 * Check whether it is a ATA device and then
                 * return  SUCCESS.
                 */
                DAD_DEBUG2(devp->dcd_dev, dcd_label, DCD_DEBUG,
                    "config %x\n", devp->dcd_ident->dcd_config);
                if ((devp->dcd_ident->dcd_config & ATAPI_DEVICE) == 0) {
                        if (devp->dcd_ident->dcd_config & ATANON_REMOVABLE) {
                                rval = DDI_PROBE_SUCCESS;
                        } else
                                rval = DDI_PROBE_FAILURE;
                } else {
                        rval = DDI_PROBE_FAILURE;
                }
                break;
        }
        dcd_unprobe(devp);

        DAD_DEBUG2(devp->dcd_dev, dcd_label, DCD_DEBUG,
            "dcdprobe returns %x\n", rval);

        return (rval);
}


/*ARGSUSED*/
static int
dcdattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
        int instance, rval;
        struct dcd_device *devp;
        struct dcd_disk *un;
        struct diskhd *dp;
        char    *pm_comp[] =
            { "NAME=ide-disk", "0=standby", "1=idle", "2=active" };

        /* CONSTCOND */
        ASSERT(NO_COMPETING_THREADS);


        devp = ddi_get_driver_private(devi);
        instance = ddi_get_instance(devi);
        DAD_DEBUG2(devp->dcd_dev, dcd_label, DCD_DEBUG, "Attach Started\n");

        switch (cmd) {
        case DDI_ATTACH:
                break;

        case DDI_RESUME:
                if (!(un = ddi_get_soft_state(dcd_state, instance)))
                        return (DDI_FAILURE);
                mutex_enter(DCD_MUTEX);
                Restore_state(un);
                /*
                 * Restore the state which was saved to give the
                 * the right state in un_last_state
                 */
                un->un_last_state = un->un_save_state;
                un->un_throttle = 2;
                cv_broadcast(&un->un_suspend_cv);
                /*
                 * Raise the power level of the device to active.
                 */
                mutex_exit(DCD_MUTEX);
                (void) pm_raise_power(DCD_DEVINFO, 0, DCD_DEVICE_ACTIVE);
                mutex_enter(DCD_MUTEX);

                /*
                 * start unit - if this is a low-activity device
                 * commands in queue will have to wait until new
                 * commands come in, which may take awhile.
                 * Also, we specifically don't check un_ncmds
                 * because we know that there really are no
                 * commands in progress after the unit was suspended
                 * and we could have reached the throttle level, been
                 * suspended, and have no new commands coming in for
                 * awhile.  Highly unlikely, but so is the low-
                 * activity disk scenario.
                 */
                dp = &un->un_utab;
                if (dp->b_actf && (dp->b_forw == NULL)) {
                        dcdstart(un);
                }

                mutex_exit(DCD_MUTEX);
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }

        if (dcd_doattach(devi, SLEEP_FUNC) == DDI_FAILURE) {
                return (DDI_FAILURE);
        }

        if (!(un = (struct dcd_disk *)
            ddi_get_soft_state(dcd_state, instance))) {
                return (DDI_FAILURE);
        }
        devp->dcd_private = (ataopaque_t)un;

        /*
         * Add a zero-length attribute to tell the world we support
         * kernel ioctls (for layered drivers)
         */
        (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
            DDI_KERNEL_IOCTL, NULL, 0);

        /*
         * Since the dad device does not have the 'reg' property,
         * cpr will not call its DDI_SUSPEND/DDI_RESUME entries.
         * The following code is to tell cpr that this device
         * does need to be suspended and resumed.
         */
        (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
            "pm-hardware-state", (caddr_t)"needs-suspend-resume");

        /*
         * Initialize power management bookkeeping;
         * Create components - In IDE case there are 3 levels and one
         * component. The levels being - active, idle, standby.
         */

        rval = ddi_prop_update_string_array(DDI_DEV_T_NONE,
            devi, "pm-components", pm_comp, 4);
        if (rval == DDI_PROP_SUCCESS) {
                /*
                 * Ignore the return value of pm_raise_power
                 * Even if we check the return values and
                 * remove the property created above, PM
                 * framework will not honour the change after
                 * first call to pm_raise_power. Hence, the
                 * removal of that property does not help if
                 * pm_raise_power fails.
                 */
                (void) pm_raise_power(DCD_DEVINFO, 0, DCD_DEVICE_ACTIVE);
        }

        ddi_report_dev(devi);

        cmlb_alloc_handle(&un->un_dklbhandle);

        if (cmlb_attach(devi,
            &dcd_lb_ops,
            0,
            B_FALSE,
            B_FALSE,
            DDI_NT_BLOCK_CHAN,
            CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8,
            un->un_dklbhandle,
            0) != 0) {
                cmlb_free_handle(&un->un_dklbhandle);
                dcd_free_softstate(un, devi);
                return (DDI_FAILURE);
        }

        mutex_enter(DCD_MUTEX);
        (void) dcd_validate_geometry(un);

        /* Get devid; create a devid ONLY IF could not get ID */
        if (dcd_get_devid(un) == NULL) {
                /* Create the fab'd devid */
                (void) dcd_create_devid(un);
        }
        mutex_exit(DCD_MUTEX);

        return (DDI_SUCCESS);
}

static void
dcd_free_softstate(struct dcd_disk *un, dev_info_t *devi)
{
        struct dcd_device               *devp;
        int instance = ddi_get_instance(devi);

        devp = ddi_get_driver_private(devi);

        if (un) {
                sema_destroy(&un->un_semoclose);
                cv_destroy(&un->un_sbuf_cv);
                cv_destroy(&un->un_state_cv);
                cv_destroy(&un->un_disk_busy_cv);
                cv_destroy(&un->un_suspend_cv);

                /*
                 * Deallocate command packet resources.
                 */
                if (un->un_sbufp)
                        freerbuf(un->un_sbufp);
                if (un->un_dp) {
                        kmem_free((caddr_t)un->un_dp, sizeof (*un->un_dp));
                }
                /*
                 * Unregister the devid and free devid resources allocated
                 */
                ddi_devid_unregister(DCD_DEVINFO);
                if (un->un_devid) {
                        ddi_devid_free(un->un_devid);
                        un->un_devid = NULL;
                }

                /*
                 * Delete kstats. Kstats for non CD devices are deleted
                 * in dcdclose.
                 */
                if (un->un_stats) {
                        kstat_delete(un->un_stats);
                }

        }

        /*
         * Cleanup scsi_device resources.
         */
        ddi_soft_state_free(dcd_state, instance);
        devp->dcd_private = (ataopaque_t)0;
        /* unprobe scsi device */
        dcd_unprobe(devp);

        /* Remove properties created during attach */
        ddi_prop_remove_all(devi);
}

static int
dcddetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
        int instance;
        struct dcd_disk *un;
        clock_t wait_cmds_complete;
        instance = ddi_get_instance(devi);

        if (!(un = ddi_get_soft_state(dcd_state, instance)))
                return (DDI_FAILURE);

        switch (cmd) {
        case DDI_DETACH:
                return (dcd_dr_detach(devi));

        case DDI_SUSPEND:
                mutex_enter(DCD_MUTEX);
                if (un->un_state == DCD_STATE_SUSPENDED) {
                        mutex_exit(DCD_MUTEX);
                        return (DDI_SUCCESS);
                }
                un->un_throttle = 0;
                /*
                 * Save the last state first
                 */
                un->un_save_state = un->un_last_state;

                New_state(un, DCD_STATE_SUSPENDED);

                /*
                 * wait till current operation completed. If we are
                 * in the resource wait state (with an intr outstanding)
                 * then we need to wait till the intr completes and
                 * starts the next cmd. We wait for
                 * DCD_WAIT_CMDS_COMPLETE seconds before failing the
                 * DDI_SUSPEND.
                 */
                wait_cmds_complete = ddi_get_lbolt();
                wait_cmds_complete +=
                    DCD_WAIT_CMDS_COMPLETE * drv_usectohz(1000000);

                while (un->un_ncmds) {
                        if (cv_timedwait(&un->un_disk_busy_cv,
                            DCD_MUTEX, wait_cmds_complete) == -1) {
                                /*
                                 * commands Didn't finish in the
                                 * specified time, fail the DDI_SUSPEND.
                                 */
                                DAD_DEBUG2(DCD_DEVINFO, dcd_label,
                                    DCD_DEBUG, "dcddetach: SUSPEND "
                                    "failed due to outstanding cmds\n");
                                Restore_state(un);
                                mutex_exit(DCD_MUTEX);
                                return (DDI_FAILURE);
                        }
                }
                mutex_exit(DCD_MUTEX);
                return (DDI_SUCCESS);
        }
        return (DDI_FAILURE);
}

/*
 * The reset entry point gets invoked at the system shutdown time or through
 * CPR code at system suspend.
 * Will be flushing the cache and expect this to be last I/O operation to the
 * disk before system reset/power off.
 */
/*ARGSUSED*/
static int
dcdreset(dev_info_t *dip, ddi_reset_cmd_t cmd)
{
        struct dcd_disk *un;
        int instance;

        instance = ddi_get_instance(dip);

        if (!(un = ddi_get_soft_state(dcd_state, instance)))
                return (DDI_FAILURE);

        dcd_flush_cache(un);

        return (DDI_SUCCESS);
}


static int
dcd_dr_detach(dev_info_t *devi)
{
        struct dcd_device       *devp;
        struct dcd_disk         *un;

        /*
         * Get scsi_device structure for this instance.
         */
        if ((devp = ddi_get_driver_private(devi)) == NULL)
                return (DDI_FAILURE);

        /*
         * Get dcd_disk structure containing target 'private' information
         */
        un = (struct dcd_disk *)devp->dcd_private;

        /*
         * Verify there are NO outstanding commands issued to this device.
         * ie, un_ncmds == 0.
         * It's possible to have outstanding commands through the physio
         * code path, even though everything's closed.
         */
#ifndef lint
        _NOTE(COMPETING_THREADS_NOW);
#endif
        mutex_enter(DCD_MUTEX);
        if (un->un_ncmds) {
                mutex_exit(DCD_MUTEX);
                _NOTE(NO_COMPETING_THREADS_NOW);
                return (DDI_FAILURE);
        }

        mutex_exit(DCD_MUTEX);

        cmlb_detach(un->un_dklbhandle, 0);
        cmlb_free_handle(&un->un_dklbhandle);


        /*
         * Lower the power state of the device
         * i.e. the minimum power consumption state - sleep.
         */
        (void) pm_lower_power(DCD_DEVINFO, 0, DCD_DEVICE_STANDBY);

        _NOTE(NO_COMPETING_THREADS_NOW);

        /*
         * at this point there are no competing threads anymore
         * release active MT locks and all device resources.
         */
        dcd_free_softstate(un, devi);

        return (DDI_SUCCESS);
}

static int
dcdpower(dev_info_t *devi, int component, int level)
{
        struct dcd_pkt *pkt;
        struct dcd_disk *un;
        int     instance;
        uchar_t cmd;


        instance = ddi_get_instance(devi);

        if (!(un = ddi_get_soft_state(dcd_state, instance)) ||
            (DCD_DEVICE_STANDBY > level) || (level > DCD_DEVICE_ACTIVE) ||
            component != 0) {
                return (DDI_FAILURE);
        }

        mutex_enter(DCD_MUTEX);
        /*
         * if there are active commands for the device or device will be
         * active soon. At the same time there is request to lower power
         * return failure.
         */
        if ((un->un_ncmds) && (level != DCD_DEVICE_ACTIVE)) {
                mutex_exit(DCD_MUTEX);
                return (DDI_FAILURE);
        }

        if ((un->un_state == DCD_STATE_OFFLINE) ||
            (un->un_state == DCD_STATE_FATAL)) {
                mutex_exit(DCD_MUTEX);
                return (DDI_FAILURE);
        }

        if (level == DCD_DEVICE_ACTIVE) {
                /*
                 * No need to fire any command, just set the state structure
                 * to indicate previous state and set the level to active
                 */
                un->un_power_level = DCD_DEVICE_ACTIVE;
                if (un->un_state == DCD_STATE_PM_SUSPENDED)
                        Restore_state(un);
                mutex_exit(DCD_MUTEX);
        } else {
                pkt = dcd_init_pkt(ROUTE, (struct dcd_pkt *)NULL,
                    NULL, (uint32_t)sizeof (struct dcd_cmd), 2, PP_LEN,
                    PKT_CONSISTENT, NULL_FUNC, NULL);

                if (pkt == (struct dcd_pkt *)NULL) {
                        mutex_exit(DCD_MUTEX);
                        return (DDI_FAILURE);
                }

                switch (level) {
                case DCD_DEVICE_IDLE:
                        cmd = ATA_IDLE_IMMEDIATE;
                        break;

                case DCD_DEVICE_STANDBY:
                        cmd = ATA_STANDBY_IMMEDIATE;
                        break;
                }

                makecommand(pkt, 0, cmd, 0, 0, 0, NO_DATA_XFER, 0);
                mutex_exit(DCD_MUTEX);
                /*
                 * Issue the appropriate command
                 */
                if ((dcd_poll(pkt)) || (SCBP_C(pkt) != STATUS_GOOD)) {
                        dcd_destroy_pkt(pkt);
                        return (DDI_FAILURE);
                }
                dcd_destroy_pkt(pkt);
                mutex_enter(DCD_MUTEX);
                if (un->un_state != DCD_STATE_PM_SUSPENDED)
                        New_state(un, DCD_STATE_PM_SUSPENDED);
                un->un_power_level = level;
                mutex_exit(DCD_MUTEX);
        }

        return (DDI_SUCCESS);
}

static int
dcd_doattach(dev_info_t *devi, int (*canwait)())
{
        struct dcd_device *devp;
        struct dcd_disk *un = (struct dcd_disk *)0;
        int instance;
        int km_flags = (canwait != NULL_FUNC)? KM_SLEEP : KM_NOSLEEP;
        int rval;
        char *prop_template = "target%x-dcd-options";
        int options;
        char    prop_str[32];
        int target;
        diskaddr_t capacity;

        devp = ddi_get_driver_private(devi);

        /*
         * Call the routine scsi_probe to do some of the dirty work.
         * If the INQUIRY command succeeds, the field dcd_inq in the
         * device structure will be filled in. The dcd_sense structure
         * will also be allocated.
         */

        switch (dcd_probe(devp, canwait)) {
        default:
                return (DDI_FAILURE);

        case DCDPROBE_EXISTS:
                if ((devp->dcd_ident->dcd_config & ATAPI_DEVICE) == 0) {
                        if (devp->dcd_ident->dcd_config & ATANON_REMOVABLE) {
                                rval = DDI_SUCCESS;
                        } else {
                                rval = DDI_FAILURE;
                                goto error;
                        }
                } else {
                        rval = DDI_FAILURE;
                        goto error;
                }
        }


        instance = ddi_get_instance(devp->dcd_dev);

        if (ddi_soft_state_zalloc(dcd_state, instance) != DDI_SUCCESS) {
                rval = DDI_FAILURE;
                goto error;
        }

        un = ddi_get_soft_state(dcd_state, instance);

        un->un_sbufp = getrbuf(km_flags);
        if (un->un_sbufp == (struct buf *)NULL) {
                rval = DDI_FAILURE;
                goto error;
        }


        un->un_dcd = devp;
        un->un_power_level = -1;
        un->un_tgattribute.media_is_writable = 1;

        sema_init(&un->un_semoclose, 1, NULL, SEMA_DRIVER, NULL);
        cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL);
        cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
        /* Initialize power management conditional variable */
        cv_init(&un->un_disk_busy_cv, NULL, CV_DRIVER, NULL);
        cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);

        if (un->un_dp == 0) {
                /*
                 * Assume CCS drive, assume parity, but call
                 * it a CDROM if it is a RODIRECT device.
                 */
                un->un_dp = (struct dcd_drivetype *)
                    kmem_zalloc(sizeof (struct dcd_drivetype), km_flags);
                if (!un->un_dp) {
                        rval = DDI_FAILURE;
                        goto error;
                }
                if ((devp->dcd_ident->dcd_config & ATAPI_DEVICE) == 0) {
                        if (devp->dcd_ident->dcd_config & ATANON_REMOVABLE) {
                                un->un_dp->ctype = CTYPE_DISK;
                        }
                } else  {
                        rval = DDI_FAILURE;
                        goto error;
                }
                un->un_dp->name = "CCS";
                un->un_dp->options = 0;
        }

        /*
         * Allow I/O requests at un_secsize offset in multiple of un_secsize.
         */
        un->un_secsize = DEV_BSIZE;

        /*
         * If the device is not a removable media device, make sure that
         * that the device is ready, by issuing the another identify but
         * not needed. Get the capacity from identify data and store here.
         */
        if (dcd_compute_dk_capacity(devp, &capacity) == 0) {
                un->un_diskcapacity = capacity;
                un->un_lbasize = DEV_BSIZE;
        }

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "Geometry Data\n");
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "cyls %x, heads %x",
            devp->dcd_ident->dcd_fixcyls,
            devp->dcd_ident->dcd_heads);
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "sectors %x,",
            devp->dcd_ident->dcd_sectors);
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "capacity %llx\n",
            capacity);

        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "dcdprobe: drive selected\n");

        /*
         * Check for the property target<n>-dcd-options to find the option
         * set by the HBA driver for this target so that we can set the
         * Unit structure variable so that we can send commands accordingly.
         */
        target = devp->dcd_address->da_target;
        (void) sprintf(prop_str, prop_template, target);
        options = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_NOTPROM,
            prop_str, -1);
        if (options < 0) {
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "No per target properties");
        } else {
                if ((options & DCD_DMA_MODE) == DCD_DMA_MODE) {
                        un->un_dp->options |= DMA_SUPPORTTED;
                        un->un_dp->dma_mode = (options >> 3) & 0x03;
                        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                            "mode %x\n", un->un_dp->dma_mode);
                } else {
                        un->un_dp->options &= ~DMA_SUPPORTTED;
                        un->un_dp->pio_mode = options & 0x7;
                        if (options & DCD_BLOCK_MODE)
                                un->un_dp->options |= BLOCK_MODE;
                        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                            "mode %x\n", un->un_dp->pio_mode);
                }
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "options %x,", un->un_dp->options);
        }

        un->un_throttle = 2;
        /*
         * set default max_xfer_size - This should depend on whether the
         * Block mode is supported by the device or not.
         */
        un->un_max_xfer_size = MAX_ATA_XFER_SIZE;

        /*
         * Set write cache enable softstate
         *
         * WCE is only supported in ATAPI-4 or higher; for
         * lower rev devices, must assume write cache is
         * enabled.
         */
        mutex_enter(DCD_MUTEX);
        un->un_write_cache_enabled = (devp->dcd_ident->dcd_majvers == 0xffff) ||
            ((devp->dcd_ident->dcd_majvers & IDENTIFY_80_ATAPI_4) == 0) ||
            (devp->dcd_ident->dcd_features85 & IDENTIFY_85_WCE) != 0;
        mutex_exit(DCD_MUTEX);

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "dcd_doattach returns good\n");

        return (rval);

error:
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "dcd_doattach failed\n");
        dcd_free_softstate(un, devi);
        return (rval);
}

#ifdef NOTNEEDED
/*
 * This routine is used to set the block mode of operation by issuing the
 * Set Block mode ata command with the maximum block mode possible
 */
dcd_set_multiple(struct dcd_disk *un)
{
        int status;
        struct udcd_cmd ucmd;
        struct dcd_cmd cdb;
        dev_t   dev;


        /* Zero all the required structure */
        (void) bzero((caddr_t)&ucmd, sizeof (ucmd));

        (void) bzero((caddr_t)&cdb, sizeof (struct dcd_cmd));

        cdb.cmd = ATA_SET_MULTIPLE;
        /*
         * Here we should pass what needs to go into sector count REGISTER.
         * Eventhough this field indicates the number of bytes to read we
         * need to specify the block factor in terms of bytes so that it
         * will be programmed by the HBA driver into the sector count register.
         */
        cdb.size = un->un_lbasize * un->un_dp->block_factor;

        cdb.sector_num.lba_num = 0;
        cdb.address_mode = ADD_LBA_MODE;
        cdb.direction = NO_DATA_XFER;

        ucmd.udcd_flags = 0;
        ucmd.udcd_cmd = &cdb;
        ucmd.udcd_bufaddr = NULL;
        ucmd.udcd_buflen = 0;
        ucmd.udcd_flags |= UDCD_SILENT;

        dev = makedevice(ddi_driver_major(DCD_DEVINFO),
            ddi_get_instance(DCD_DEVINFO) << DCDUNIT_SHIFT);


        status = dcdioctl_cmd(dev, &ucmd, UIO_SYSSPACE, UIO_SYSSPACE);

        return (status);
}
/*
 * The following routine is used only for setting the transfer mode
 * and it is not designed for transferring any other features subcommand.
 */
dcd_set_features(struct dcd_disk *un, uchar_t mode)
{
        int status;
        struct udcd_cmd ucmd;
        struct dcd_cmd cdb;
        dev_t   dev;


        /* Zero all the required structure */
        (void) bzero((caddr_t)&ucmd, sizeof (ucmd));

        (void) bzero((caddr_t)&cdb, sizeof (struct dcd_cmd));

        cdb.cmd = ATA_SET_FEATURES;
        /*
         * Here we need to pass what needs to go into the sector count register
         * But in the case of SET FEATURES command the value taken in the
         * sector count register depends what type of subcommand is
         * passed in the features register. Since we have defined the size to
         * be the size in bytes in this context it does not indicate bytes
         * instead it indicates the mode to be programmed.
         */
        cdb.size = un->un_lbasize * mode;

        cdb.sector_num.lba_num = 0;
        cdb.address_mode = ADD_LBA_MODE;
        cdb.direction = NO_DATA_XFER;
        cdb.features = ATA_FEATURE_SET_MODE;
        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "size %x, features %x, cmd %x\n",
            cdb.size, cdb.features, cdb.cmd);

        ucmd.udcd_flags = 0;
        ucmd.udcd_cmd = &cdb;
        ucmd.udcd_bufaddr = NULL;
        ucmd.udcd_buflen = 0;
        ucmd.udcd_flags |= UDCD_SILENT;

        dev = makedevice(ddi_driver_major(DCD_DEVINFO),
            ddi_get_instance(DCD_DEVINFO) << DCDUNIT_SHIFT);

        status = dcdioctl_cmd(dev, &ucmd, UIO_SYSSPACE, UIO_SYSSPACE);

        return (status);
}
#endif

/*
 * Validate the geometry for this disk, e.g.,
 * see whether it has a valid label.
 */
static int
dcd_validate_geometry(struct dcd_disk *un)
{
        int secsize = 0;
        struct  dcd_device *devp;
        int secdiv;
        int rval;

        ASSERT(mutex_owned(DCD_MUTEX));
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "dcd_validate_geometry: started \n");

        if (un->un_lbasize < 0) {
                return (DCD_BAD_LABEL);
        }

        if (un->un_state == DCD_STATE_PM_SUSPENDED) {
                mutex_exit(DCD_MUTEX);
                if (pm_raise_power(DCD_DEVINFO, 0, DCD_DEVICE_ACTIVE) !=
                    DDI_SUCCESS) {
                        mutex_enter(DCD_MUTEX);
                        return (DCD_BAD_LABEL);
                }
                mutex_enter(DCD_MUTEX);
        }

        secsize = un->un_secsize;

        /*
         * take a log base 2 of sector size (sorry)
         */
        for (secdiv = 0; secsize = secsize >> 1; secdiv++)
                ;
        un->un_secdiv = secdiv;

        /*
         * Only DIRECT ACCESS devices will have Sun labels.
         * CD's supposedly have a Sun label, too
         */

        devp = un->un_dcd;

        if (((devp->dcd_ident->dcd_config & ATAPI_DEVICE) == 0) &&
            (devp->dcd_ident->dcd_config & ATANON_REMOVABLE)) {
                mutex_exit(DCD_MUTEX);
                rval = cmlb_validate(un->un_dklbhandle, 0, 0);
                mutex_enter(DCD_MUTEX);
                if (rval == ENOMEM)
                        return (DCD_NO_MEM_FOR_LABEL);
                else if (rval != 0)
                        return (DCD_BAD_LABEL);
        } else {
                /* it should never get here. */
                return (DCD_BAD_LABEL);
        }

        /*
         * take a log base 2 of logical block size
         */
        secsize = un->un_lbasize;
        for (secdiv = 0; secsize = secsize >> 1; secdiv++)
                ;
        un->un_lbadiv = secdiv;

        /*
         * take a log base 2 of the multiple of DEV_BSIZE blocks that
         * make up one logical block
         */
        secsize = un->un_lbasize >> DEV_BSHIFT;
        for (secdiv = 0; secsize = secsize >> 1; secdiv++)
                ;
        un->un_blknoshift = secdiv;
        return (0);
}

/*
 * Unix Entry Points
 */

/* ARGSUSED3 */
static int
dcdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
{
        dev_t dev = *dev_p;
        int rval = EIO;
        int partmask;
        int nodelay = (flag & (FNDELAY | FNONBLOCK));
        int i;
        char kstatname[KSTAT_STRLEN];
        diskaddr_t lblocks;
        char *partname;

        GET_SOFT_STATE(dev);

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "Inside Open flag %x, otyp %x\n", flag, otyp);

        if (otyp >= OTYPCNT) {
                return (EINVAL);
        }

        partmask = 1 << part;

        /*
         * We use a semaphore here in order to serialize
         * open and close requests on the device.
         */
        sema_p(&un->un_semoclose);

        mutex_enter(DCD_MUTEX);

        if ((un->un_state & DCD_STATE_FATAL) == DCD_STATE_FATAL) {
                rval = ENXIO;
                goto done;
        }

        while (un->un_state == DCD_STATE_SUSPENDED) {
                cv_wait(&un->un_suspend_cv, DCD_MUTEX);
        }

        if ((un->un_state == DCD_STATE_PM_SUSPENDED) && (!nodelay)) {
                mutex_exit(DCD_MUTEX);
                if (pm_raise_power(DCD_DEVINFO, 0, DCD_DEVICE_ACTIVE)
                    != DDI_SUCCESS) {
                        mutex_enter(DCD_MUTEX);
                        rval = EIO;
                        goto done;
                }
                mutex_enter(DCD_MUTEX);
        }

        /*
         * set make_dcd_cmd() flags and stat_size here since these
         * are unlikely to change
         */
        un->un_cmd_flags = 0;

        un->un_cmd_stat_size = 2;

        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG, "dcdopen un=0x%p\n",
            (void *)un);
        /*
         * check for previous exclusive open
         */
        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "exclopen=%x, flag=%x, regopen=%x\n",
            un->un_exclopen, flag, un->un_ocmap.regopen[otyp]);
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "Exclusive open flag %x, partmask %x\n",
            un->un_exclopen, partmask);

        if (un->un_exclopen & (partmask)) {
failed_exclusive:
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "exclusive open fails\n");
                rval = EBUSY;
                goto done;
        }

        if (flag & FEXCL) {
                int i;
                if (un->un_ocmap.lyropen[part]) {
                        goto failed_exclusive;
                }
                for (i = 0; i < (OTYPCNT - 1); i++) {
                        if (un->un_ocmap.regopen[i] & (partmask)) {
                                goto failed_exclusive;
                        }
                }
        }
        if (flag & FWRITE) {
                mutex_exit(DCD_MUTEX);
                if (dcd_check_wp(dev)) {
                        sema_v(&un->un_semoclose);
                        return (EROFS);
                }
                mutex_enter(DCD_MUTEX);
        }

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "Check Write Protect handled\n");

        if (!nodelay) {
                mutex_exit(DCD_MUTEX);
                if ((rval = dcd_ready_and_valid(dev, un)) != 0) {
                        rval = EIO;
                }
                (void) pm_idle_component(DCD_DEVINFO, 0);
                /*
                 * Fail if device is not ready or if the number of disk
                 * blocks is zero or negative for non CD devices.
                 */
                if (rval || cmlb_partinfo(un->un_dklbhandle,
                    part, &lblocks, NULL, &partname, NULL, 0) ||
                    lblocks <= 0) {
                        rval = EIO;
                        mutex_enter(DCD_MUTEX);
                        goto done;
                }
                mutex_enter(DCD_MUTEX);
        }

        if (otyp == OTYP_LYR) {
                un->un_ocmap.lyropen[part]++;
        } else {
                un->un_ocmap.regopen[otyp] |= partmask;
        }

        /*
         * set up open and exclusive open flags
         */
        if (flag & FEXCL) {
                un->un_exclopen |= (partmask);
        }


        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "open of part %d type %d\n",
            part, otyp);

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "Kstats getting updated\n");
        /*
         * only create kstats for disks, CD kstats created in dcdattach
         */
        _NOTE(NO_COMPETING_THREADS_NOW);
        mutex_exit(DCD_MUTEX);
        if (un->un_stats == (kstat_t *)0) {
                un->un_stats = kstat_create("dad", instance,
                    NULL, "disk", KSTAT_TYPE_IO, 1,
                    KSTAT_FLAG_PERSISTENT);
                if (un->un_stats) {
                        un->un_stats->ks_lock = DCD_MUTEX;
                        kstat_install(un->un_stats);
                }

                /*
                 * set up partition statistics for each partition
                 * with number of blocks > 0
                 */
                if (!nodelay) {
                        for (i = 0; i < NDKMAP; i++) {
                                if ((un->un_pstats[i] == (kstat_t *)0) &&
                                    (cmlb_partinfo(un->un_dklbhandle,
                                    i, &lblocks, NULL, &partname,
                                    NULL, 0) == 0) && lblocks > 0) {
                                        (void) sprintf(kstatname, "dad%d,%s",
                                            instance, partname);
                                        un->un_pstats[i] = kstat_create("dad",
                                            instance,
                                            kstatname,
                                            "partition",
                                            KSTAT_TYPE_IO,
                                            1,
                                            KSTAT_FLAG_PERSISTENT);
                                        if (un->un_pstats[i]) {
                                                un->un_pstats[i]->ks_lock =
                                                    DCD_MUTEX;
                                                kstat_install(un->un_pstats[i]);
                                        }
                                }
                        }
                }
                /*
                 * set up error kstats
                 */
                (void) dcd_create_errstats(un, instance);
        }
#ifndef lint
        _NOTE(COMPETING_THREADS_NOW);
#endif

        sema_v(&un->un_semoclose);
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "Open success\n");
        return (0);

done:
        mutex_exit(DCD_MUTEX);
        sema_v(&un->un_semoclose);
        return (rval);

}

/*
 * Test if disk is ready and has a valid geometry.
 */
static int
dcd_ready_and_valid(dev_t dev, struct dcd_disk *un)
{
        int rval = 1;
        int g_error = 0;

        mutex_enter(DCD_MUTEX);
        /*
         * cmds outstanding
         */
        if (un->un_ncmds == 0) {
                (void) dcd_unit_ready(dev);
        }

        /*
         * If device is not yet ready here, inform it is offline
         */
        if (un->un_state == DCD_STATE_NORMAL) {
                rval = dcd_unit_ready(dev);
                if (rval != 0 && rval != EACCES) {
                        dcd_offline(un, 1);
                        goto done;
                }
        }

        if (un->un_format_in_progress == 0) {
                g_error = dcd_validate_geometry(un);
        }

        /*
         * check if geometry was valid. We don't check the validity of
         * geometry for CDROMS.
         */

        if (g_error == DCD_BAD_LABEL) {
                rval = 1;
                goto done;
        }


        /*
         * the state has changed; inform the media watch routines
         */
        un->un_mediastate = DKIO_INSERTED;
        cv_broadcast(&un->un_state_cv);
        rval = 0;

done:
        mutex_exit(DCD_MUTEX);
        return (rval);
}


/*ARGSUSED*/
static int
dcdclose(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
        uchar_t *cp;
        int i;

        GET_SOFT_STATE(dev);


        if (otyp >= OTYPCNT)
                return (ENXIO);

        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "close of part %d type %d\n",
            part, otyp);
        sema_p(&un->un_semoclose);

        mutex_enter(DCD_MUTEX);

        if (un->un_exclopen & (1<<part)) {
                un->un_exclopen &= ~(1<<part);
        }

        if (otyp == OTYP_LYR) {
                un->un_ocmap.lyropen[part] -= 1;
        } else {
                un->un_ocmap.regopen[otyp] &= ~(1<<part);
        }

        cp = &un->un_ocmap.chkd[0];
        while (cp < &un->un_ocmap.chkd[OCSIZE]) {
                if (*cp != (uchar_t)0) {
                        break;
                }
                cp++;
        }

        if (cp == &un->un_ocmap.chkd[OCSIZE]) {
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG, "last close\n");
                if (un->un_state == DCD_STATE_OFFLINE) {
                        dcd_offline(un, 1);
                }

                mutex_exit(DCD_MUTEX);
                (void) cmlb_close(un->un_dklbhandle, 0);

                _NOTE(NO_COMPETING_THREADS_NOW);
                if (un->un_stats) {
                        kstat_delete(un->un_stats);
                        un->un_stats = 0;
                }
                for (i = 0; i < NDKMAP; i++) {
                        if (un->un_pstats[i]) {
                                kstat_delete(un->un_pstats[i]);
                                un->un_pstats[i] = (kstat_t *)0;
                        }
                }

                if (un->un_errstats) {
                        kstat_delete(un->un_errstats);
                        un->un_errstats = (kstat_t *)0;
                }
                mutex_enter(DCD_MUTEX);

#ifndef lint
                _NOTE(COMPETING_THREADS_NOW);
#endif
        }

        mutex_exit(DCD_MUTEX);
        sema_v(&un->un_semoclose);
        return (0);
}

static void
dcd_offline(struct dcd_disk *un, int bechatty)
{
        if (bechatty)
                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN, "offline\n");

        mutex_exit(DCD_MUTEX);
        cmlb_invalidate(un->un_dklbhandle, 0);
        mutex_enter(DCD_MUTEX);
}

/*
 * Given the device number return the devinfo pointer
 * from the scsi_device structure.
 */
/*ARGSUSED*/
static int
dcdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
        dev_t dev;
        struct dcd_disk *un;
        int instance, error;


        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                dev = (dev_t)arg;
                instance = DCDUNIT(dev);
                if ((un = ddi_get_soft_state(dcd_state, instance)) == NULL)
                        return (DDI_FAILURE);
                *result = (void *) DCD_DEVINFO;
                error = DDI_SUCCESS;
                break;
        case DDI_INFO_DEVT2INSTANCE:
                dev = (dev_t)arg;
                instance = DCDUNIT(dev);
                *result = (void *)(uintptr_t)instance;
                error = DDI_SUCCESS;
                break;
        default:
                error = DDI_FAILURE;
        }
        return (error);
}

/*
 * property operation routine.  return the number of blocks for the partition
 * in question or forward the request to the propery facilities.
 */
static int
dcd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
    char *name, caddr_t valuep, int *lengthp)
{
        struct dcd_disk *un;

        if ((un = ddi_get_soft_state(dcd_state, ddi_get_instance(dip))) == NULL)
                return (ddi_prop_op(dev, dip, prop_op, mod_flags,
                    name, valuep, lengthp));

        return (cmlb_prop_op(un->un_dklbhandle,
            dev, dip, prop_op, mod_flags, name, valuep, lengthp,
            DCDPART(dev), NULL));
}

/*
 * These routines perform raw i/o operations.
 */
/*ARGSUSED*/
void
dcduscsimin(struct buf *bp)
{

}


static void
dcdmin(struct buf *bp)
{
        struct dcd_disk *un;
        int instance;
        minor_t minor = getminor(bp->b_edev);
        instance = minor >> DCDUNIT_SHIFT;
        un = ddi_get_soft_state(dcd_state, instance);

        if (bp->b_bcount > un->un_max_xfer_size)
                bp->b_bcount = un->un_max_xfer_size;
}


/* ARGSUSED2 */
static int
dcdread(dev_t dev, struct uio *uio, cred_t *cred_p)
{
        int secmask;
        GET_SOFT_STATE(dev);
#ifdef lint
        part = part;
#endif /* lint */
        secmask = un->un_secsize - 1;

        if (uio->uio_loffset & ((offset_t)(secmask))) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "file offset not modulo %d\n",
                    un->un_secsize);
                return (EINVAL);
        } else if (uio->uio_iov->iov_len & (secmask)) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "transfer length not modulo %d\n", un->un_secsize);
                return (EINVAL);
        }
        return (physio(dcdstrategy, (struct buf *)0, dev, B_READ, dcdmin, uio));
}

/* ARGSUSED2 */
static int
dcdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
{
        int secmask;
        struct uio *uio = aio->aio_uio;
        GET_SOFT_STATE(dev);
#ifdef lint
        part = part;
#endif /* lint */
        secmask = un->un_secsize - 1;

        if (uio->uio_loffset & ((offset_t)(secmask))) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "file offset not modulo %d\n",
                    un->un_secsize);
                return (EINVAL);
        } else if (uio->uio_iov->iov_len & (secmask)) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "transfer length not modulo %d\n", un->un_secsize);
                return (EINVAL);
        }
        return (aphysio(dcdstrategy, anocancel, dev, B_READ, dcdmin, aio));
}

/* ARGSUSED2 */
static int
dcdwrite(dev_t dev, struct uio *uio, cred_t *cred_p)
{
        int secmask;
        GET_SOFT_STATE(dev);
#ifdef lint
        part = part;
#endif /* lint */
        secmask = un->un_secsize - 1;

        if (uio->uio_loffset & ((offset_t)(secmask))) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "file offset not modulo %d\n",
                    un->un_secsize);
                return (EINVAL);
        } else if (uio->uio_iov->iov_len & (secmask)) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "transfer length not modulo %d\n", un->un_secsize);
                return (EINVAL);
        }
        return (physio(dcdstrategy, (struct buf *)0, dev, B_WRITE, dcdmin,
            uio));
}

/* ARGSUSED2 */
static int
dcdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
{
        int secmask;
        struct uio *uio = aio->aio_uio;
        GET_SOFT_STATE(dev);
#ifdef lint
        part = part;
#endif /* lint */
        secmask = un->un_secsize - 1;

        if (uio->uio_loffset & ((offset_t)(secmask))) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "file offset not modulo %d\n",
                    un->un_secsize);
                return (EINVAL);
        } else if (uio->uio_iov->iov_len & (secmask)) {
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "transfer length not modulo %d\n", un->un_secsize);
                return (EINVAL);
        }
        return (aphysio(dcdstrategy, anocancel, dev, B_WRITE, dcdmin, aio));
}

/*
 * strategy routine
 */
static int
dcdstrategy(struct buf *bp)
{
        struct dcd_disk *un;
        struct diskhd *dp;
        int i;
        minor_t minor = getminor(bp->b_edev);
        diskaddr_t p_lblksrt;
        diskaddr_t lblocks;
        diskaddr_t bn;

        if ((un = ddi_get_soft_state(dcd_state,
            minor >> DCDUNIT_SHIFT)) == NULL ||
            un->un_state == DCD_STATE_DUMPING ||
            ((un->un_state  & DCD_STATE_FATAL) == DCD_STATE_FATAL)) {
                SET_BP_ERROR(bp, ((un) ? ENXIO : EIO));
error:
                bp->b_resid = bp->b_bcount;
                biodone(bp);
                return (0);
        }

        /*
         * If the request size (buf->b_bcount)is greater than the size
         * (un->un_max_xfer_size) supported by the target driver fail
         * the request with EINVAL error code.
         *
         * We are not supposed to receive requests exceeding
         * un->un_max_xfer_size size because the caller is expected to
         * check what is the maximum size that is supported by this
         * driver either through ioctl or dcdmin routine(which is private
         * to this driver).
         * But we have seen cases (like meta driver(md))where dcdstrategy
         * called with more than supported size and cause data corruption.
         */

        if (bp->b_bcount > un->un_max_xfer_size) {
                SET_BP_ERROR(bp, EINVAL);
                goto error;
        }

        TRACE_2(TR_FAC_DADA, TR_DCDSTRATEGY_START,
            "dcdstrategy_start: bp 0x%p un 0x%p", bp, un);

        /*
         * Commands may sneak in while we released the mutex in
         * DDI_SUSPEND, we should block new commands.
         */
        mutex_enter(DCD_MUTEX);
        while (un->un_state == DCD_STATE_SUSPENDED) {
                cv_wait(&un->un_suspend_cv, DCD_MUTEX);
        }

        if (un->un_state == DCD_STATE_PM_SUSPENDED) {
                mutex_exit(DCD_MUTEX);
                (void) pm_idle_component(DCD_DEVINFO, 0);
                if (pm_raise_power(DCD_DEVINFO, 0,
                    DCD_DEVICE_ACTIVE) !=  DDI_SUCCESS) {
                        SET_BP_ERROR(bp, EIO);
                        goto error;
                }
                mutex_enter(DCD_MUTEX);
        }
        mutex_exit(DCD_MUTEX);

        /*
         * Map-in the buffer in case starting address is not word aligned.
         */

        if (((uintptr_t)bp->b_un.b_addr) & 0x1)
                bp_mapin(bp);

        bp->b_flags &= ~(B_DONE|B_ERROR);
        bp->b_resid = 0;
        bp->av_forw = 0;

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "bp->b_bcount %lx\n", bp->b_bcount);

        if (bp != un->un_sbufp) {
validated:      if (cmlb_partinfo(un->un_dklbhandle,
                    minor & DCDPART_MASK,
                    &lblocks,
                    &p_lblksrt,
                    NULL,
                    NULL,
                    0) == 0) {

                        bn = dkblock(bp);

                        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                            "dkblock(bp) is %llu\n", bn);

                        i = 0;
                        if (bn < 0) {
                                i = -1;
                        } else if (bn >= lblocks) {
                                /*
                                 * For proper comparison, file system block
                                 * number has to be scaled to actual CD
                                 * transfer size.
                                 * Since all the CDROM operations
                                 * that have Sun Labels are in the correct
                                 * block size this will work for CD's.  This
                                 * will have to change when we have different
                                 * sector sizes.
                                 *
                                 * if bn == lblocks,
                                 * Not an error, resid == count
                                 */
                                if (bn > lblocks) {
                                        i = -1;
                                } else {
                                        i = 1;
                                }
                        } else if (bp->b_bcount & (un->un_secsize-1)) {
                                /*
                                 * This should really be:
                                 *
                                 * ... if (bp->b_bcount & (un->un_lbasize-1))
                                 *
                                 */
                                i = -1;
                        } else {
                                if (!bp->b_bcount) {
                                        printf("Waring : Zero read or Write\n");
                                        goto error;
                                }
                                /*
                                 * sort by absolute block number.
                                 */
                                bp->b_resid = bn;
                                bp->b_resid += p_lblksrt;
                                /*
                                 * zero out av_back - this will be a signal
                                 * to dcdstart to go and fetch the resources
                                 */
                                bp->av_back = NO_PKT_ALLOCATED;
                        }

                        /*
                         * Check to see whether or not we are done
                         * (with or without errors).
                         */

                        if (i != 0) {
                                if (i < 0) {
                                        bp->b_flags |= B_ERROR;
                                }
                                goto error;
                        }
                } else {
                        /*
                         * opened in NDELAY/NONBLOCK mode?
                         * Check if disk is ready and has a valid geometry
                         */
                        if (dcd_ready_and_valid(bp->b_edev, un) == 0) {
                                goto validated;
                        } else {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                                    "i/o to invalid geometry\n");
                                SET_BP_ERROR(bp, EIO);
                                goto error;
                        }
                }
        } else if (BP_HAS_NO_PKT(bp)) {
                struct udcd_cmd *tscmdp;
                struct dcd_cmd *tcmdp;
                /*
                 * This indicates that it is a special buffer
                 * This could be a udcd-cmd and hence call bp_mapin just
                 * in case that it could be a PIO command issued.
                 */
                tscmdp = (struct udcd_cmd *)bp->b_forw;
                tcmdp = tscmdp->udcd_cmd;
                if ((tcmdp->cmd != ATA_READ_DMA) && (tcmdp->cmd != 0xc9) &&
                    (tcmdp->cmd != ATA_WRITE_DMA) && (tcmdp->cmd != 0xcb) &&
                    (tcmdp->cmd != IDENTIFY_DMA) &&
                    (tcmdp->cmd != ATA_FLUSH_CACHE)) {
                        bp_mapin(bp);
                }
        }

        /*
         * We are doing it a bit non-standard. That is, the
         * head of the b_actf chain is *not* the active command-
         * it is just the head of the wait queue. The reason
         * we do this is that the head of the b_actf chain is
         * guaranteed to not be moved by disksort(), so that
         * our restart command (pointed to by
         * b_forw) and the head of the wait queue (b_actf) can
         * have resources granted without it getting lost in
         * the queue at some later point (where we would have
         * to go and look for it).
         */
        mutex_enter(DCD_MUTEX);

        DCD_DO_KSTATS(un, kstat_waitq_enter, bp);

        dp = &un->un_utab;

        if (dp->b_actf == NULL) {
                dp->b_actf = bp;
                dp->b_actl = bp;
        } else if ((un->un_state == DCD_STATE_SUSPENDED) &&
            bp == un->un_sbufp) {
                bp->b_actf = dp->b_actf;
                dp->b_actf = bp;
        } else {
                TRACE_3(TR_FAC_DADA, TR_DCDSTRATEGY_DISKSORT_START,
                    "dcdstrategy_disksort_start: dp 0x%p bp 0x%p un 0x%p",
                    dp, bp, un);
                disksort(dp, bp);
                TRACE_0(TR_FAC_DADA, TR_DCDSTRATEGY_DISKSORT_END,
                    "dcdstrategy_disksort_end");
        }

        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "ncmd %x , throttle %x, forw 0x%p\n",
            un->un_ncmds, un->un_throttle, (void *)dp->b_forw);
        ASSERT(un->un_ncmds >= 0);
        ASSERT(un->un_throttle >= 0);
        if ((un->un_ncmds < un->un_throttle) && (dp->b_forw == NULL)) {
                dcdstart(un);
        } else if (BP_HAS_NO_PKT(dp->b_actf)) {
                struct buf *cmd_bp;

                cmd_bp = dp->b_actf;
                cmd_bp->av_back = ALLOCATING_PKT;
                mutex_exit(DCD_MUTEX);
                /*
                 * try and map this one
                 */
                TRACE_0(TR_FAC_DADA, TR_DCDSTRATEGY_SMALL_WINDOW_START,
                    "dcdstrategy_small_window_call (begin)");

                make_dcd_cmd(un, cmd_bp, NULL_FUNC);

                TRACE_0(TR_FAC_DADA, TR_DCDSTRATEGY_SMALL_WINDOW_END,
                    "dcdstrategy_small_window_call (end)");

                /*
                 * there is a small window where the active cmd
                 * completes before make_dcd_cmd returns.
                 * consequently, this cmd never gets started so
                 * we start it from here
                 */
                mutex_enter(DCD_MUTEX);
                if ((un->un_ncmds < un->un_throttle) &&
                    (dp->b_forw == NULL)) {
                        dcdstart(un);
                }
        }
        mutex_exit(DCD_MUTEX);

done:
        TRACE_0(TR_FAC_DADA, TR_DCDSTRATEGY_END, "dcdstrategy_end");
        return (0);
}


/*
 * Unit start and Completion
 * NOTE: we assume that the caller has at least checked for:
 *              (un->un_ncmds < un->un_throttle)
 *      if not, there is no real harm done, dcd_transport() will
 *      return BUSY
 */
static void
dcdstart(struct dcd_disk *un)
{
        int status, sort_key;
        struct buf *bp;
        struct diskhd *dp;
        uchar_t state = un->un_last_state;

        TRACE_1(TR_FAC_DADA, TR_DCDSTART_START, "dcdstart_start: un 0x%p", un);

retry:
        ASSERT(mutex_owned(DCD_MUTEX));

        dp = &un->un_utab;
        if (((bp = dp->b_actf) == NULL) || (bp->av_back == ALLOCATING_PKT) ||
            (dp->b_forw != NULL)) {
                TRACE_0(TR_FAC_DADA, TR_DCDSTART_NO_WORK_END,
                    "dcdstart_end (no work)");
                return;
        }

        /*
         * remove from active queue
         */
        dp->b_actf = bp->b_actf;
        bp->b_actf = 0;

        /*
         * increment ncmds before calling dcd_transport because dcdintr
         * may be called before we return from dcd_transport!
         */
        un->un_ncmds++;

        /*
         * If measuring stats, mark exit from wait queue and
         * entrance into run 'queue' if and only if we are
         * going to actually start a command.
         * Normally the bp already has a packet at this point
         */
        DCD_DO_KSTATS(un, kstat_waitq_to_runq, bp);

        mutex_exit(DCD_MUTEX);

        if (BP_HAS_NO_PKT(bp)) {
                make_dcd_cmd(un, bp, dcdrunout);
                if (BP_HAS_NO_PKT(bp) && !(bp->b_flags & B_ERROR)) {
                        mutex_enter(DCD_MUTEX);
                        DCD_DO_KSTATS(un, kstat_runq_back_to_waitq, bp);

                        bp->b_actf = dp->b_actf;
                        dp->b_actf = bp;
                        New_state(un, DCD_STATE_RWAIT);
                        un->un_ncmds--;
                        TRACE_0(TR_FAC_DADA, TR_DCDSTART_NO_RESOURCES_END,
                            "dcdstart_end (No Resources)");
                        goto done;

                } else if (bp->b_flags & B_ERROR) {
                        mutex_enter(DCD_MUTEX);
                        DCD_DO_KSTATS(un, kstat_runq_exit, bp);

                        un->un_ncmds--;
                        bp->b_resid = bp->b_bcount;
                        if (bp->b_error == 0) {
                                SET_BP_ERROR(bp, EIO);
                        }

                        /*
                         * restore old state
                         */
                        un->un_state = un->un_last_state;
                        un->un_last_state = state;

                        mutex_exit(DCD_MUTEX);

                        biodone(bp);
                        mutex_enter(DCD_MUTEX);
                        if (un->un_state == DCD_STATE_SUSPENDED) {
                                cv_broadcast(&un->un_disk_busy_cv);
                        }

                        if ((un->un_ncmds < un->un_throttle) &&
                            (dp->b_forw == NULL)) {
                                goto retry;
                        } else {
                                goto done;
                        }
                }
        }

        /*
         * Restore resid from the packet, b_resid had been the
         * disksort key.
         */
        sort_key = bp->b_resid;
        bp->b_resid = BP_PKT(bp)->pkt_resid;
        BP_PKT(bp)->pkt_resid = 0;

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "bp->b_resid %lx, pkt_resid %lx\n",
            bp->b_resid, BP_PKT(bp)->pkt_resid);

        /*
         * We used to check whether or not to try and link commands here.
         * Since we have found that there is no performance improvement
         * for linked commands, this has not made much sense.
         */
        if ((status = dcd_transport((struct dcd_pkt *)BP_PKT(bp)))
            != TRAN_ACCEPT) {
                mutex_enter(DCD_MUTEX);
                un->un_ncmds--;
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "transport returned %x\n", status);
                if (status == TRAN_BUSY) {
                        DCD_DO_ERRSTATS(un, dcd_transerrs);
                        DCD_DO_KSTATS(un, kstat_runq_back_to_waitq, bp);
                        dcd_handle_tran_busy(bp, dp, un);
                        if (un->un_ncmds > 0) {
                                bp->b_resid = sort_key;
                        }
                } else {
                        DCD_DO_KSTATS(un, kstat_runq_exit, bp);
                        mutex_exit(DCD_MUTEX);

                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "transport rejected (%d)\n",
                            status);
                        SET_BP_ERROR(bp, EIO);
                        bp->b_resid = bp->b_bcount;
                        if (bp != un->un_sbufp) {
                                dcd_destroy_pkt(BP_PKT(bp));
                        }
                        biodone(bp);

                        mutex_enter(DCD_MUTEX);
                        if (un->un_state == DCD_STATE_SUSPENDED) {
                                cv_broadcast(&un->un_disk_busy_cv);
                        }
                        if ((un->un_ncmds < un->un_throttle) &&
                            (dp->b_forw == NULL)) {
                                        goto retry;
                        }
                }
        } else {
                mutex_enter(DCD_MUTEX);

                if (dp->b_actf && BP_HAS_NO_PKT(dp->b_actf)) {
                        struct buf *cmd_bp;

                        cmd_bp = dp->b_actf;
                        cmd_bp->av_back = ALLOCATING_PKT;
                        mutex_exit(DCD_MUTEX);
                        /*
                         * try and map this one
                         */
                        TRACE_0(TR_FAC_DADA, TR_DCASTART_SMALL_WINDOW_START,
                            "dcdstart_small_window_start");

                        make_dcd_cmd(un, cmd_bp, NULL_FUNC);

                        TRACE_0(TR_FAC_DADA, TR_DCDSTART_SMALL_WINDOW_END,
                            "dcdstart_small_window_end");
                        /*
                         * there is a small window where the active cmd
                         * completes before make_dcd_cmd returns.
                         * consequently, this cmd never gets started so
                         * we start it from here
                         */
                        mutex_enter(DCD_MUTEX);
                        if ((un->un_ncmds < un->un_throttle) &&
                            (dp->b_forw == NULL)) {
                                goto retry;
                        }
                }
        }

done:
        ASSERT(mutex_owned(DCD_MUTEX));
        TRACE_0(TR_FAC_DADA, TR_DCDSTART_END, "dcdstart_end");
}

/*
 * make_dcd_cmd: create a pkt
 */
static void
make_dcd_cmd(struct dcd_disk *un, struct buf *bp, int (*func)())
{
        auto int count, com, direction;
        struct dcd_pkt *pkt;
        int flags, tval;

        _NOTE(DATA_READABLE_WITHOUT_LOCK(dcd_disk::un_dp))
        TRACE_3(TR_FAC_DADA, TR_MAKE_DCD_CMD_START,
            "make_dcd_cmd_start: un 0x%p bp 0x%p un 0x%p", un, bp, un);


        flags = un->un_cmd_flags;

        if (bp != un->un_sbufp) {
                int partition = DCDPART(bp->b_edev);
                diskaddr_t p_lblksrt;
                diskaddr_t lblocks;
                long secnt;
                uint32_t blkno;
                int dkl_nblk, delta;
                long resid;

                if (cmlb_partinfo(un->un_dklbhandle,
                    partition,
                    &lblocks,
                    &p_lblksrt,
                    NULL,
                    NULL,
                    0) != 0) {
                        lblocks = 0;
                        p_lblksrt = 0;
                }

                dkl_nblk = (int)lblocks;

                /*
                 * Make sure we don't run off the end of a partition.
                 *
                 * Put this test here so that we can adjust b_count
                 * to accurately reflect the actual amount we are
                 * goint to transfer.
                 */

                /*
                 * First, compute partition-relative block number
                 */
                blkno = dkblock(bp);
                secnt = (bp->b_bcount + (un->un_secsize - 1)) >> un->un_secdiv;
                count = MIN(secnt, dkl_nblk - blkno);
                if (count != secnt) {
                        /*
                         * We have an overrun
                         */
                        resid = (secnt - count) << un->un_secdiv;
                        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                            "overrun by %ld sectors\n",
                            secnt - count);
                        bp->b_bcount -= resid;
                } else {
                        resid = 0;
                }

                /*
                 * Adjust block number to absolute
                 */
                delta = (int)p_lblksrt;
                blkno += delta;

                mutex_enter(DCD_MUTEX);
                /*
                 * This is for devices having block size different from
                 * from DEV_BSIZE (e.g. 2K CDROMs).
                 */
                if (un->un_lbasize != un->un_secsize) {
                        blkno >>= un->un_blknoshift;
                        count >>= un->un_blknoshift;
                }
                mutex_exit(DCD_MUTEX);

                TRACE_0(TR_FAC_DADA, TR_MAKE_DCD_CMD_INIT_PKT_START,
                    "make_dcd_cmd_init_pkt_call (begin)");
                pkt = dcd_init_pkt(ROUTE, NULL, bp,
                    (uint32_t)sizeof (struct dcd_cmd),
                    un->un_cmd_stat_size, PP_LEN, PKT_CONSISTENT,
                    func, (caddr_t)un);
                TRACE_1(TR_FAC_DADA, TR_MAKE_DCD_CMD_INIT_PKT_END,
                    "make_dcd_cmd_init_pkt_call (end): pkt 0x%p", pkt);
                if (!pkt) {
                        bp->b_bcount += resid;
                        bp->av_back = NO_PKT_ALLOCATED;
                        TRACE_0(TR_FAC_DADA,
                            TR_MAKE_DCD_CMD_NO_PKT_ALLOCATED1_END,
                            "make_dcd_cmd_end (NO_PKT_ALLOCATED1)");
                        return;
                }
                if (bp->b_flags & B_READ) {
                        if ((un->un_dp->options & DMA_SUPPORTTED) ==
                            DMA_SUPPORTTED) {
                                com = ATA_READ_DMA;
                        } else {
                                if (un->un_dp->options & BLOCK_MODE)
                                        com = ATA_READ_MULTIPLE;
                                else
                                        com = ATA_READ;
                        }
                        direction = DATA_READ;
                } else {
                        if ((un->un_dp->options & DMA_SUPPORTTED) ==
                            DMA_SUPPORTTED) {
                                com = ATA_WRITE_DMA;
                        } else {
                                if (un->un_dp->options & BLOCK_MODE)
                                        com = ATA_WRITE_MULTIPLE;
                                else
                                        com = ATA_WRITE;
                        }
                        direction = DATA_WRITE;
                }

                /*
                 * Save the resid in the packet, temporarily until
                 * we transport the command.
                 */
                pkt->pkt_resid = resid;

                makecommand(pkt, flags, com, blkno, ADD_LBA_MODE,
                    bp->b_bcount, direction, 0);
                tval = dcd_io_time;
        } else {

                struct udcd_cmd *scmd = (struct udcd_cmd *)bp->b_forw;

                /*
                 * set options
                 */
                if ((scmd->udcd_flags & UDCD_SILENT) && !(DEBUGGING)) {
                        flags |= FLAG_SILENT;
                }
                if (scmd->udcd_flags &  UDCD_DIAGNOSE)
                        flags |= FLAG_DIAGNOSE;

                if (scmd->udcd_flags & UDCD_NOINTR)
                        flags |= FLAG_NOINTR;

                pkt = dcd_init_pkt(ROUTE, (struct dcd_pkt *)NULL,
                    (bp->b_bcount)? bp: NULL,
                    (uint32_t)sizeof (struct dcd_cmd),
                    2, PP_LEN, PKT_CONSISTENT, func, (caddr_t)un);

                if (!pkt) {
                        bp->av_back = NO_PKT_ALLOCATED;
                        return;
                }

                makecommand(pkt, 0, scmd->udcd_cmd->cmd,
                    scmd->udcd_cmd->sector_num.lba_num,
                    scmd->udcd_cmd->address_mode,
                    scmd->udcd_cmd->size,
                    scmd->udcd_cmd->direction, scmd->udcd_cmd->features);

                pkt->pkt_flags = flags;
                if (scmd->udcd_timeout == 0)
                        tval = dcd_io_time;
                else
                        tval = scmd->udcd_timeout;
                /* UDAD interface should be decided. */
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "udcd interface\n");
        }

        pkt->pkt_comp = dcdintr;
        pkt->pkt_time = tval;
        PKT_SET_BP(pkt, bp);
        bp->av_back = (struct buf *)pkt;

        TRACE_0(TR_FAC_DADA, TR_MAKE_DCD_CMD_END, "make_dcd_cmd_end");
}

/*
 * Command completion processing
 */
static void
dcdintr(struct dcd_pkt *pkt)
{
        struct dcd_disk *un;
        struct buf *bp;
        int action;
        int status;

        bp = PKT_GET_BP(pkt);
        un = ddi_get_soft_state(dcd_state, DCDUNIT(bp->b_edev));

        TRACE_1(TR_FAC_DADA, TR_DCDINTR_START, "dcdintr_start: un 0x%p", un);
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "dcdintr\n");

        mutex_enter(DCD_MUTEX);
        un->un_ncmds--;
        DCD_DO_KSTATS(un, kstat_runq_exit, bp);
        ASSERT(un->un_ncmds >= 0);

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "reason %x and Status %x\n", pkt->pkt_reason, SCBP_C(pkt));

        /*
         * do most common case first
         */
        if ((pkt->pkt_reason == CMD_CMPLT) && (SCBP_C(pkt) == 0)) {
                int com = GETATACMD((struct dcd_cmd *)pkt->pkt_cdbp);

                if (un->un_state == DCD_STATE_OFFLINE) {
                        un->un_state = un->un_last_state;
                        dcd_log(DCD_DEVINFO, dcd_label, CE_NOTE,
                            (const char *) diskokay);
                }
                /*
                 * If the command is a read or a write, and we have
                 * a non-zero pkt_resid, that is an error. We should
                 * attempt to retry the operation if possible.
                 */
                action = COMMAND_DONE;
                if (pkt->pkt_resid && (com == ATA_READ || com == ATA_WRITE)) {
                        DCD_DO_ERRSTATS(un, dcd_harderrs);
                        if ((int)PKT_GET_RETRY_CNT(pkt) < dcd_retry_count) {
                                PKT_INCR_RETRY_CNT(pkt, 1);
                                action = QUE_COMMAND;
                        } else {
                                /*
                                 * if we have exhausted retries
                                 * a command with a residual is in error in
                                 * this case.
                                 */
                                action = COMMAND_DONE_ERROR;
                        }
                        dcd_log(DCD_DEVINFO, dcd_label,
                            CE_WARN, "incomplete %s- %s\n",
                            (bp->b_flags & B_READ)? "read" : "write",
                            (action == QUE_COMMAND)? "retrying" :
                            "giving up");
                }

                /*
                 * pkt_resid will reflect, at this point, a residual
                 * of how many bytes left to be transferred there were
                 * from the actual scsi command. Add this to b_resid i.e
                 * the amount this driver could not see to transfer,
                 * to get the total number of bytes not transfered.
                 */
                if (action != QUE_COMMAND) {
                        bp->b_resid += pkt->pkt_resid;
                }

        } else if (pkt->pkt_reason != CMD_CMPLT) {
                action = dcd_handle_incomplete(un, bp);
        }

        /*
         * If we are in the middle of syncing or dumping, we have got
         * here because dcd_transport has called us explictly after
         * completing the command in a polled mode. We don't want to
         * have a recursive call into dcd_transport again.
         */
        if (ddi_in_panic() && (action == QUE_COMMAND)) {
                action = COMMAND_DONE_ERROR;
        }

        /*
         * save pkt reason; consecutive failures are not reported unless
         * fatal
         * do not reset last_pkt_reason when the cmd was retried and
         * succeeded because
         * there maybe more commands comming back with last_pkt_reason
         */
        if ((un->un_last_pkt_reason != pkt->pkt_reason) &&
            ((pkt->pkt_reason != CMD_CMPLT) ||
            (PKT_GET_RETRY_CNT(pkt) == 0))) {
                un->un_last_pkt_reason = pkt->pkt_reason;
        }

        switch (action) {
        case COMMAND_DONE_ERROR:
error:
                if (bp->b_resid == 0) {
                        bp->b_resid = bp->b_bcount;
                }
                if (bp->b_error == 0) {
                        struct  dcd_cmd *cdbp = (struct dcd_cmd *)pkt->pkt_cdbp;
                        if (cdbp->cmd == ATA_FLUSH_CACHE &&
                            (pkt->pkt_scbp[0] & STATUS_ATA_ERR) &&
                            (pkt->pkt_scbp[1] & ERR_ABORT)) {
                                SET_BP_ERROR(bp, ENOTSUP);
                                un->un_flush_not_supported = 1;
                        } else {
                                SET_BP_ERROR(bp, EIO);
                        }
                }
                bp->b_flags |= B_ERROR;
                /*FALLTHROUGH*/
        case COMMAND_DONE:
                dcddone_and_mutex_exit(un, bp);

                TRACE_0(TR_FAC_DADA, TR_DCDINTR_COMMAND_DONE_END,
                    "dcdintr_end (COMMAND_DONE)");
                return;

        case QUE_COMMAND:
                if (un->un_ncmds >= un->un_throttle) {
                        struct diskhd *dp = &un->un_utab;

                        bp->b_actf = dp->b_actf;
                        dp->b_actf = bp;

                        DCD_DO_KSTATS(un, kstat_waitq_enter, bp);

                        mutex_exit(DCD_MUTEX);
                        goto exit;
                }

                un->un_ncmds++;
                /* reset the pkt reason again */
                pkt->pkt_reason = 0;
                DCD_DO_KSTATS(un, kstat_runq_enter, bp);
                mutex_exit(DCD_MUTEX);
                if ((status = dcd_transport(BP_PKT(bp))) != TRAN_ACCEPT) {
                        struct diskhd *dp = &un->un_utab;

                        mutex_enter(DCD_MUTEX);
                        un->un_ncmds--;
                        if (status == TRAN_BUSY) {
                                DCD_DO_KSTATS(un, kstat_runq_back_to_waitq, bp);
                                dcd_handle_tran_busy(bp, dp, un);
                                mutex_exit(DCD_MUTEX);
                                goto exit;
                        }
                        DCD_DO_ERRSTATS(un, dcd_transerrs);
                        DCD_DO_KSTATS(un, kstat_runq_exit, bp);

                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "requeue of command fails (%x)\n", status);
                        SET_BP_ERROR(bp, EIO);
                        bp->b_resid = bp->b_bcount;

                        dcddone_and_mutex_exit(un, bp);
                        goto exit;
                }
                break;

        case JUST_RETURN:
        default:
                DCD_DO_KSTATS(un, kstat_waitq_enter, bp);
                mutex_exit(DCD_MUTEX);
                break;
        }

exit:
        TRACE_0(TR_FAC_DADA, TR_DCDINTR_END, "dcdintr_end");
}


/*
 * Done with a command.
 */
static void
dcddone_and_mutex_exit(struct dcd_disk *un, register struct buf *bp)
{
        struct diskhd *dp;

        TRACE_1(TR_FAC_DADA, TR_DCDONE_START, "dcddone_start: un 0x%p", un);

        _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_dcd->dcd_mutex));

        dp = &un->un_utab;
        if (bp == dp->b_forw) {
                dp->b_forw = NULL;
        }

        if (un->un_stats) {
                ulong_t n_done = bp->b_bcount - bp->b_resid;
                if (bp->b_flags & B_READ) {
                        IOSP->reads++;
                        IOSP->nread += n_done;
                } else {
                        IOSP->writes++;
                        IOSP->nwritten += n_done;
                }
        }
        if (IO_PARTITION_STATS) {
                ulong_t n_done = bp->b_bcount - bp->b_resid;
                if (bp->b_flags & B_READ) {
                        IOSP_PARTITION->reads++;
                        IOSP_PARTITION->nread += n_done;
                } else {
                        IOSP_PARTITION->writes++;
                        IOSP_PARTITION->nwritten += n_done;
                }
        }

        /*
         * Start the next one before releasing resources on this one
         */
        if (un->un_state == DCD_STATE_SUSPENDED) {
                cv_broadcast(&un->un_disk_busy_cv);
        } else if (dp->b_actf && (un->un_ncmds < un->un_throttle) &&
            (dp->b_forw == NULL && un->un_state != DCD_STATE_SUSPENDED)) {
                dcdstart(un);
        }

        mutex_exit(DCD_MUTEX);

        if (bp != un->un_sbufp) {
                dcd_destroy_pkt(BP_PKT(bp));
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "regular done: resid %ld\n", bp->b_resid);
        } else {
                ASSERT(un->un_sbuf_busy);
        }
        TRACE_0(TR_FAC_DADA, TR_DCDDONE_BIODONE_CALL, "dcddone_biodone_call");

        biodone(bp);

        (void) pm_idle_component(DCD_DEVINFO, 0);

        TRACE_0(TR_FAC_DADA, TR_DCDDONE_END, "dcddone end");
}


/*
 * reset the disk unless the transport layer has already
 * cleared the problem
 */
#define C1      (STAT_ATA_BUS_RESET|STAT_ATA_DEV_RESET|STAT_ATA_ABORTED)
static void
dcd_reset_disk(struct dcd_disk *un, struct dcd_pkt *pkt)
{

        if ((pkt->pkt_statistics & C1) == 0) {
                mutex_exit(DCD_MUTEX);
                if (!dcd_reset(ROUTE, RESET_ALL)) {
                        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                            "Reset failed");
                }
                mutex_enter(DCD_MUTEX);
        }
}

static int
dcd_handle_incomplete(struct dcd_disk *un, struct buf *bp)
{
        static char *fail = "ATA transport failed: reason '%s': %s\n";
        static char *notresp = "disk not responding to selection\n";
        int rval = COMMAND_DONE_ERROR;
        int action = COMMAND_SOFT_ERROR;
        struct dcd_pkt *pkt = BP_PKT(bp);
        int be_chatty = (un->un_state != DCD_STATE_SUSPENDED) &&
            (bp != un->un_sbufp || !(pkt->pkt_flags & FLAG_SILENT));

        ASSERT(mutex_owned(DCD_MUTEX));

        switch (pkt->pkt_reason) {

        case CMD_TIMEOUT:
                /*
                 * This Indicates the already the HBA would  have reset
                 * so Just indicate to retry the command
                 */
                break;

        case CMD_INCOMPLETE:
                action = dcd_check_error(un, bp);
                DCD_DO_ERRSTATS(un, dcd_transerrs);
                if (action == COMMAND_HARD_ERROR) {
                        (void) dcd_reset_disk(un, pkt);
                }
                break;

        case CMD_FATAL:
                /*
                 * Something drastic has gone wrong
                 */
                break;
        case CMD_DMA_DERR:
        case CMD_DATA_OVR:
                /* FALLTHROUGH */

        default:
                /*
                 * the target may still be running the  command,
                 * so we should try and reset that target.
                 */
                DCD_DO_ERRSTATS(un, dcd_transerrs);
                if ((pkt->pkt_reason != CMD_RESET) &&
                    (pkt->pkt_reason != CMD_ABORTED)) {
                        (void) dcd_reset_disk(un, pkt);
                }
                break;
        }

        /*
         * If pkt_reason is CMD_RESET/ABORTED, chances are that this pkt got
         * reset/aborted because another disk on this bus caused it.
         * The disk that caused it, should get CMD_TIMEOUT with pkt_statistics
         * of STAT_TIMEOUT/STAT_DEV_RESET
         */
        if ((pkt->pkt_reason == CMD_RESET) ||(pkt->pkt_reason == CMD_ABORTED)) {
                /* To be written : XXX */
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "Command aborted\n");
        }

        if (bp == un->un_sbufp && (pkt->pkt_flags & FLAG_DIAGNOSE)) {
                rval = COMMAND_DONE_ERROR;
        } else {
                if ((rval == COMMAND_DONE_ERROR) &&
                    (action == COMMAND_SOFT_ERROR) &&
                    ((int)PKT_GET_RETRY_CNT(pkt) < dcd_retry_count)) {
                        PKT_INCR_RETRY_CNT(pkt, 1);
                        rval = QUE_COMMAND;
                }
        }

        if (pkt->pkt_reason == CMD_INCOMPLETE && rval == COMMAND_DONE_ERROR) {
                /*
                 * Looks like someone turned off this shoebox.
                 */
                if (un->un_state != DCD_STATE_OFFLINE) {
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            (const char *) notresp);
                        New_state(un, DCD_STATE_OFFLINE);
                }
        } else if (pkt->pkt_reason == CMD_FATAL) {
                /*
                 * Suppressing the following message for the time being
                 * dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                 * (const char *) notresp);
                 */
                PKT_INCR_RETRY_CNT(pkt, 6);
                rval = COMMAND_DONE_ERROR;
                New_state(un, DCD_STATE_FATAL);
        } else if (be_chatty) {
                int in_panic = ddi_in_panic();
                if (!in_panic || (rval == COMMAND_DONE_ERROR)) {
                        if (((pkt->pkt_reason != un->un_last_pkt_reason) &&
                            (pkt->pkt_reason != CMD_RESET)) ||
                            (rval == COMMAND_DONE_ERROR) ||
                            (dcd_error_level == DCD_ERR_ALL)) {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                                    fail, dcd_rname(pkt->pkt_reason),
                                    (rval == COMMAND_DONE_ERROR) ?
                                    "giving up": "retrying command");
                                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                                    "retrycount=%x\n",
                                    PKT_GET_RETRY_CNT(pkt));
                        }
                }
        }
error:
        return (rval);
}

static int
dcd_check_error(struct dcd_disk *un, struct buf *bp)
{
        struct diskhd *dp = &un->un_utab;
        struct dcd_pkt *pkt = BP_PKT(bp);
        int rval = 0;
        unsigned char status;
        unsigned char error;

        TRACE_0(TR_FAC_DADA, TR_DCD_CHECK_ERROR_START, "dcd_check_error_start");
        ASSERT(mutex_owned(DCD_MUTEX));

        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "Pkt: 0x%p dp: 0x%p\n", (void *)pkt, (void *)dp);

        /*
         * Here we need to check status first and then if error is indicated
         * Then the error register.
         */

        status = (pkt->pkt_scbp)[0];
        if ((status & STATUS_ATA_DWF) == STATUS_ATA_DWF) {
                /*
                 * There has been a Device Fault  - reason for such error
                 * is vendor specific
                 * Action to be taken is - Indicate error and reset device.
                 */

                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN, "Device Fault\n");
                rval = COMMAND_HARD_ERROR;
        } else if ((status & STATUS_ATA_CORR) == STATUS_ATA_CORR) {

                /*
                 * The sector read or written is marginal and hence ECC
                 * Correction has been applied. Indicate to repair
                 * Here we need to probably re-assign based on the badblock
                 * mapping.
                 */

                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                    "Soft Error on block %x\n",
                    ((struct dcd_cmd *)pkt->pkt_cdbp)->sector_num.lba_num);
                rval = COMMAND_SOFT_ERROR;
        } else if ((status & STATUS_ATA_ERR) == STATUS_ATA_ERR) {
                error = pkt->pkt_scbp[1];

                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                    "Command:0x%x,Error:0x%x,Status:0x%x\n",
                    GETATACMD((struct dcd_cmd *)pkt->pkt_cdbp),
                    error, status);
                if ((error &  ERR_AMNF) == ERR_AMNF) {
                        /* Address make not found */
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "Address Mark Not Found");
                } else if ((error & ERR_TKONF) == ERR_TKONF) {
                        /* Track 0 Not found */
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "Track 0 Not found \n");
                } else if ((error & ERR_IDNF) == ERR_IDNF) {
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            " ID not found \n");
                } else if ((error &  ERR_UNC) == ERR_UNC) {
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "Uncorrectable data Error: Block %x\n",
                            ((struct dcd_cmd *)pkt->pkt_cdbp)->
                            sector_num.lba_num);
                } else if ((error & ERR_BBK) == ERR_BBK) {
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "Bad block detected: Block %x\n",
                            ((struct dcd_cmd *)pkt->pkt_cdbp)->
                            sector_num.lba_num);
                } else if ((error & ERR_ABORT) == ERR_ABORT) {
                        /* Aborted Command */
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            " Aborted Command \n");
                }
                /*
                 * Return the soft error so that the command
                 * will be retried.
                 */
                rval = COMMAND_SOFT_ERROR;
        }

        TRACE_0(TR_FAC_DADA, TR_DCD_CHECK_ERROR_END, "dcd_check_error_end");
        return (rval);
}


/*
 *      System Crash Dump routine
 */

#define NDUMP_RETRIES   5

static int
dcddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
{
        struct dcd_pkt *pkt;
        int i;
        struct buf local, *bp;
        int err;
        unsigned char com;
        diskaddr_t p_lblksrt;
        diskaddr_t lblocks;

        GET_SOFT_STATE(dev);
#ifdef lint
        part = part;
#endif /* lint */

        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*un))

        if ((un->un_state & DCD_STATE_FATAL) == DCD_STATE_FATAL)
                return (ENXIO);

        if (cmlb_partinfo(un->un_dklbhandle, DCDPART(dev),
            &lblocks, &p_lblksrt, NULL, NULL, 0))
                return (ENXIO);

        if (blkno+nblk > lblocks) {
                return (EINVAL);
        }


        if ((un->un_state == DCD_STATE_SUSPENDED) ||
            (un->un_state == DCD_STATE_PM_SUSPENDED)) {
                if (pm_raise_power(DCD_DEVINFO, 0,
                    DCD_DEVICE_ACTIVE) != DDI_SUCCESS) {
                        return (EIO);
                }
        }

        /*
         * When cpr calls dcddump, we know that dad is in a
         * a good state, so no bus reset is required
         */
        un->un_throttle = 0;

        if ((un->un_state != DCD_STATE_SUSPENDED) &&
            (un->un_state != DCD_STATE_DUMPING)) {

                New_state(un, DCD_STATE_DUMPING);

                /*
                 * Reset the bus. I'd like to not have to do this,
                 * but this is the safest thing to do...
                 */

                if (dcd_reset(ROUTE, RESET_ALL) == 0) {
                        return (EIO);
                }

        }

        blkno += p_lblksrt;

        /*
         * It should be safe to call the allocator here without
         * worrying about being locked for DVMA mapping because
         * the address we're passed is already a DVMA mapping
         *
         * We are also not going to worry about semaphore ownership
         * in the dump buffer. Dumping is single threaded at present.
         */

        bp = &local;
        bzero((caddr_t)bp, sizeof (*bp));
        bp->b_flags = B_BUSY;
        bp->b_un.b_addr = addr;
        bp->b_bcount = nblk << DEV_BSHIFT;
        bp->b_resid = 0;

        for (i = 0; i < NDUMP_RETRIES; i++) {
                bp->b_flags &= ~B_ERROR;
                if ((pkt = dcd_init_pkt(ROUTE, NULL, bp,
                    (uint32_t)sizeof (struct dcd_cmd), 2, PP_LEN,
                    PKT_CONSISTENT, NULL_FUNC, NULL)) != NULL) {
                        break;
                }
                if (i == 0) {
                        if (bp->b_flags & B_ERROR) {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                                    "no resources for dumping; "
                                    "error code: 0x%x, retrying",
                                    geterror(bp));
                        } else {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                                    "no resources for dumping; retrying");
                        }
                } else if (i != (NDUMP_RETRIES - 1)) {
                        if (bp->b_flags & B_ERROR) {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_CONT, "no "
                                    "resources for dumping; error code: 0x%x, "
                                    "retrying\n", geterror(bp));
                        }
                } else {
                        if (bp->b_flags & B_ERROR) {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_CONT,
                                    "no resources for dumping; "
                                    "error code: 0x%x, retries failed, "
                                    "giving up.\n", geterror(bp));
                        } else {
                                dcd_log(DCD_DEVINFO, dcd_label, CE_CONT,
                                    "no resources for dumping; "
                                    "retries failed, giving up.\n");
                        }
                        return (EIO);
                }
                delay(10);
        }
        if ((un->un_dp->options & DMA_SUPPORTTED) == DMA_SUPPORTTED) {
                com = ATA_WRITE_DMA;
        } else {
                if (un->un_dp->options & BLOCK_MODE)
                        com = ATA_WRITE_MULTIPLE;
                else
                        com = ATA_WRITE;
        }

        makecommand(pkt, 0, com, blkno, ADD_LBA_MODE,
            (int)nblk*un->un_secsize, DATA_WRITE, 0);

        for (err = EIO, i = 0; i < NDUMP_RETRIES && err == EIO; i++) {

                if (dcd_poll(pkt) == 0) {
                        switch (SCBP_C(pkt)) {
                        case STATUS_GOOD:
                                if (pkt->pkt_resid == 0) {
                                        err = 0;
                                }
                                break;
                        case STATUS_ATA_BUSY:
                                (void) dcd_reset(ROUTE, RESET_TARGET);
                                break;
                        default:
                                mutex_enter(DCD_MUTEX);
                                (void) dcd_reset_disk(un, pkt);
                                mutex_exit(DCD_MUTEX);
                                break;
                        }
                } else if (i > NDUMP_RETRIES/2) {
                        (void) dcd_reset(ROUTE, RESET_ALL);
                }

        }
        dcd_destroy_pkt(pkt);
        return (err);
}

/*
 * This routine implements the ioctl calls.  It is called
 * from the device switch at normal priority.
 */
/* ARGSUSED3 */
static int
dcdioctl(dev_t dev, int cmd, intptr_t arg, int flag,
    cred_t *cred_p, int *rval_p)
{
        auto int32_t data[512 / (sizeof (int32_t))];
        struct dk_cinfo *info;
        struct dk_minfo media_info;
        struct udcd_cmd *scmd;
        int i, err;
        enum uio_seg uioseg = 0;
        enum dkio_state state = 0;
#ifdef _MULTI_DATAMODEL
        struct dadkio_rwcmd rwcmd;
#endif
        struct dadkio_rwcmd32 rwcmd32;
        struct dcd_cmd dcdcmd;

        GET_SOFT_STATE(dev);
#ifdef lint
        part = part;
        state = state;
        uioseg = uioseg;
#endif  /* lint */

        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "dcd_ioctl : cmd %x, arg %lx\n", cmd, arg);

        bzero((caddr_t)data, sizeof (data));

        switch (cmd) {

#ifdef DCDDEBUG
/*
 * Following ioctl are for testing RESET/ABORTS
 */
#define DKIOCRESET      (DKIOC|14)
#define DKIOCABORT      (DKIOC|15)

        case DKIOCRESET:
                if (ddi_copyin((caddr_t)arg, (caddr_t)data, 4, flag))
                        return (EFAULT);
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "DKIOCRESET: data = 0x%x\n", data[0]);
                if (dcd_reset(ROUTE, data[0])) {
                        return (0);
                } else {
                        return (EIO);
                }
        case DKIOCABORT:
                DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "DKIOCABORT:\n");
                if (dcd_abort(ROUTE, (struct dcd_pkt *)0)) {
                        return (0);
                } else {
                        return (EIO);
                }
#endif

        case DKIOCINFO:
                /*
                 * Controller Information
                 */
                info = (struct dk_cinfo *)data;

                mutex_enter(DCD_MUTEX);
                switch (un->un_dp->ctype) {
                default:
                        info->dki_ctype = DKC_DIRECT;
                        break;
                }
                mutex_exit(DCD_MUTEX);
                info->dki_cnum = ddi_get_instance(ddi_get_parent(DCD_DEVINFO));
                (void) strcpy(info->dki_cname,
                    ddi_get_name(ddi_get_parent(DCD_DEVINFO)));
                /*
                 * Unit Information
                 */
                info->dki_unit = ddi_get_instance(DCD_DEVINFO);
                info->dki_slave = (Tgt(DCD_DCD_DEVP)<<3);
                (void) strcpy(info->dki_dname, ddi_driver_name(DCD_DEVINFO));
                info->dki_flags = DKI_FMTVOL;
                info->dki_partition = DCDPART(dev);

                /*
                 * Max Transfer size of this device in blocks
                 */
                info->dki_maxtransfer = un->un_max_xfer_size / DEV_BSIZE;

                /*
                 * We can't get from here to there yet
                 */
                info->dki_addr = 0;
                info->dki_space = 0;
                info->dki_prio = 0;
                info->dki_vec = 0;

                i = sizeof (struct dk_cinfo);
                if (ddi_copyout((caddr_t)data, (caddr_t)arg, i, flag))
                        return (EFAULT);
                else
                        return (0);

        case DKIOCGMEDIAINFO:
                /*
                 * As dad target driver is used for IDE disks only
                 * Can keep the return value hardcoded to FIXED_DISK
                 */
                media_info.dki_media_type = DK_FIXED_DISK;

                mutex_enter(DCD_MUTEX);
                media_info.dki_lbsize = un->un_lbasize;
                media_info.dki_capacity = un->un_diskcapacity;
                mutex_exit(DCD_MUTEX);

                if (ddi_copyout(&media_info, (caddr_t)arg,
                    sizeof (struct dk_minfo), flag))
                        return (EFAULT);
                else
                        return (0);

        case DKIOCGGEOM:
        case DKIOCGVTOC:
        case DKIOCGETEFI:

                mutex_enter(DCD_MUTEX);
                if (un->un_ncmds == 0) {
                        if ((err = dcd_unit_ready(dev)) != 0) {
                                mutex_exit(DCD_MUTEX);
                                return (err);
                        }
                }

                mutex_exit(DCD_MUTEX);
                err = cmlb_ioctl(un->un_dklbhandle, dev, cmd,
                    arg, flag, cred_p, rval_p, 0);
                return (err);

        case DKIOCGAPART:
        case DKIOCSAPART:
        case DKIOCSGEOM:
        case DKIOCSVTOC:
        case DKIOCSETEFI:
        case DKIOCPARTITION:
        case DKIOCPARTINFO:
        case DKIOCGMBOOT:
        case DKIOCSMBOOT:

                err = cmlb_ioctl(un->un_dklbhandle, dev, cmd,
                    arg, flag, cred_p, rval_p, 0);
                return (err);

        case DIOCTL_RWCMD:
                if (drv_priv(cred_p) != 0) {
                        return (EPERM);
                }

#ifdef _MULTI_DATAMODEL
                switch (ddi_model_convert_from(flag & FMODELS)) {
                case DDI_MODEL_NONE:
                        if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd,
                            sizeof (struct dadkio_rwcmd), flag)) {
                                return (EFAULT);
                        }
                        rwcmd32.cmd = rwcmd.cmd;
                        rwcmd32.flags = rwcmd.flags;
                        rwcmd32.blkaddr = rwcmd.blkaddr;
                        rwcmd32.buflen = rwcmd.buflen;
                        rwcmd32.bufaddr = (caddr32_t)(uintptr_t)rwcmd.bufaddr;
                        break;
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd32,
                            sizeof (struct dadkio_rwcmd32), flag)) {
                                return (EFAULT);
                        }
                        break;
                }
#else
                if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd32,
                    sizeof (struct dadkio_rwcmd32), flag)) {
                        return (EFAULT);
                }
#endif
                mutex_enter(DCD_MUTEX);

                uioseg  = UIO_SYSSPACE;
                scmd = (struct udcd_cmd *)data;
                scmd->udcd_cmd = &dcdcmd;
                /*
                 * Convert the dadkio_rwcmd structure to udcd_cmd so that
                 * it can take the normal path to get the io done
                 */
                if (rwcmd32.cmd == DADKIO_RWCMD_READ) {
                        if ((un->un_dp->options & DMA_SUPPORTTED) ==
                            DMA_SUPPORTTED)
                                scmd->udcd_cmd->cmd = ATA_READ_DMA;
                        else
                                scmd->udcd_cmd->cmd = ATA_READ;
                        scmd->udcd_cmd->address_mode = ADD_LBA_MODE;
                        scmd->udcd_cmd->direction = DATA_READ;
                        scmd->udcd_flags |= UDCD_READ|UDCD_SILENT;
                } else if (rwcmd32.cmd == DADKIO_RWCMD_WRITE) {
                        if ((un->un_dp->options & DMA_SUPPORTTED) ==
                            DMA_SUPPORTTED)
                                scmd->udcd_cmd->cmd = ATA_WRITE_DMA;
                        else
                                scmd->udcd_cmd->cmd = ATA_WRITE;
                        scmd->udcd_cmd->direction = DATA_WRITE;
                        scmd->udcd_flags |= UDCD_WRITE|UDCD_SILENT;
                } else {
                        mutex_exit(DCD_MUTEX);
                        return (EINVAL);
                }

                scmd->udcd_cmd->address_mode = ADD_LBA_MODE;
                scmd->udcd_cmd->features = 0;
                scmd->udcd_cmd->size = rwcmd32.buflen;
                scmd->udcd_cmd->sector_num.lba_num = rwcmd32.blkaddr;
                scmd->udcd_bufaddr = (caddr_t)(uintptr_t)rwcmd32.bufaddr;
                scmd->udcd_buflen = rwcmd32.buflen;
                scmd->udcd_timeout = (ushort_t)dcd_io_time;
                scmd->udcd_resid = 0ULL;
                scmd->udcd_status = 0;
                scmd->udcd_error_reg = 0;
                scmd->udcd_status_reg = 0;

                mutex_exit(DCD_MUTEX);

                i = dcdioctl_cmd(dev, scmd, UIO_SYSSPACE, UIO_USERSPACE);
                mutex_enter(DCD_MUTEX);
                /*
                 * After return convert the status from scmd to
                 * dadkio_status
                 */
                (void) dcd_translate(&(rwcmd32.status), scmd);
                rwcmd32.status.resid = scmd->udcd_resid;
                mutex_exit(DCD_MUTEX);

#ifdef _MULTI_DATAMODEL
                switch (ddi_model_convert_from(flag & FMODELS)) {
                case DDI_MODEL_NONE: {
                        int counter;
                        rwcmd.status.status = rwcmd32.status.status;
                        rwcmd.status.resid  = rwcmd32.status.resid;
                        rwcmd.status.failed_blk_is_valid =
                            rwcmd32.status.failed_blk_is_valid;
                        rwcmd.status.failed_blk = rwcmd32.status.failed_blk;
                        rwcmd.status.fru_code_is_valid =
                            rwcmd32.status.fru_code_is_valid;
                        rwcmd.status.fru_code = rwcmd32.status.fru_code;
                        for (counter = 0;
                            counter < DADKIO_ERROR_INFO_LEN; counter++)
                                rwcmd.status.add_error_info[counter] =
                                    rwcmd32.status.add_error_info[counter];
                        }
                        /* Copy out the result back to the user program */
                        if (ddi_copyout((caddr_t)&rwcmd, (caddr_t)arg,
                            sizeof (struct dadkio_rwcmd), flag)) {
                                if (i != 0) {
                                        i = EFAULT;
                                }
                        }
                        break;
                case DDI_MODEL_ILP32:
                        /* Copy out the result back to the user program */
                        if (ddi_copyout((caddr_t)&rwcmd32, (caddr_t)arg,
                            sizeof (struct dadkio_rwcmd32), flag)) {
                                if (i != 0) {
                                        i = EFAULT;
                                }
                        }
                        break;
                }
#else
                /* Copy out the result back to the user program  */
                if (ddi_copyout((caddr_t)&rwcmd32, (caddr_t)arg,
                    sizeof (struct dadkio_rwcmd32), flag)) {
                        if (i != 0)
                                i = EFAULT;
                }
#endif
                return (i);

        case UDCDCMD:   {
#ifdef  _MULTI_DATAMODEL
                /*
                 * For use when a 32 bit app makes a call into a
                 * 64 bit ioctl
                 */
                struct udcd_cmd32       udcd_cmd_32_for_64;
                struct udcd_cmd32       *ucmd32 = &udcd_cmd_32_for_64;
                model_t                 model;
#endif /* _MULTI_DATAMODEL */

                if (drv_priv(cred_p) != 0) {
                        return (EPERM);
                }

                scmd = (struct udcd_cmd *)data;

#ifdef _MULTI_DATAMODEL
                switch (model = ddi_model_convert_from(flag & FMODELS)) {
                case DDI_MODEL_ILP32:
                        if (ddi_copyin((caddr_t)arg, ucmd32,
                            sizeof (struct udcd_cmd32), flag)) {
                                return (EFAULT);
                        }
                        /*
                         * Convert the ILP32 uscsi data from the
                         * application to LP64 for internal use.
                         */
                        udcd_cmd32toudcd_cmd(ucmd32, scmd);
                        break;
                case DDI_MODEL_NONE:
                        if (ddi_copyin((caddr_t)arg, scmd, sizeof (*scmd),
                            flag)) {
                                return (EFAULT);
                        }
                        break;
                }
#else /* ! _MULTI_DATAMODEL */
                if (ddi_copyin((caddr_t)arg, (caddr_t)scmd,
                    sizeof (*scmd), flag)) {
                        return (EFAULT);
                }
#endif /* ! _MULTI_DATAMODEL */

                scmd->udcd_flags &= ~UDCD_NOINTR;
                uioseg = (flag & FKIOCTL)? UIO_SYSSPACE: UIO_USERSPACE;

                i = dcdioctl_cmd(dev, scmd, uioseg, uioseg);
#ifdef _MULTI_DATAMODEL
                switch (model) {
                case DDI_MODEL_ILP32:
                        /*
                         * Convert back to ILP32 before copyout to the
                         * application
                         */
                        udcd_cmdtoudcd_cmd32(scmd, ucmd32);
                        if (ddi_copyout(ucmd32, (caddr_t)arg,
                            sizeof (*ucmd32), flag)) {
                                if (i != 0)
                                        i = EFAULT;
                        }
                        break;
                case DDI_MODEL_NONE:
                        if (ddi_copyout(scmd, (caddr_t)arg, sizeof (*scmd),
                            flag)) {
                                if (i != 0)
                                        i = EFAULT;
                        }
                        break;
                }
#else /* ! _MULTI_DATAMODE */
                if (ddi_copyout((caddr_t)scmd, (caddr_t)arg,
                    sizeof (*scmd), flag)) {
                        if (i != 0)
                                i = EFAULT;
                }
#endif
                return (i);
        }
        case DKIOCFLUSHWRITECACHE:      {
                struct dk_callback *dkc = (struct dk_callback *)arg;
                struct dcd_pkt *pkt;
                struct buf *bp;
                int is_sync = 1;

                mutex_enter(DCD_MUTEX);
                if (un->un_flush_not_supported ||
                    ! un->un_write_cache_enabled) {
                        i = un->un_flush_not_supported ? ENOTSUP : 0;
                        mutex_exit(DCD_MUTEX);
                        /*
                         * If a callback was requested: a callback will
                         * always be done if the caller saw the
                         * DKIOCFLUSHWRITECACHE ioctl return 0, and
                         * never done if the caller saw the ioctl return
                         * an error.
                         */
                        if ((flag & FKIOCTL) && dkc != NULL &&
                            dkc->dkc_callback != NULL) {
                                (*dkc->dkc_callback)(dkc->dkc_cookie, i);
                                /*
                                 * Did callback and reported error.
                                 * Since we did a callback, ioctl
                                 * should return 0.
                                 */
                                i = 0;
                        }
                        return (i);
                }

                /*
                 * Get the special buffer
                 */
                while (un->un_sbuf_busy) {
                        cv_wait(&un->un_sbuf_cv, DCD_MUTEX);
                }
                un->un_sbuf_busy = 1;
                bp  = un->un_sbufp;
                mutex_exit(DCD_MUTEX);

                pkt = dcd_init_pkt(ROUTE, (struct dcd_pkt *)NULL,
                    NULL, (uint32_t)sizeof (struct dcd_cmd),
                    2, PP_LEN, PKT_CONSISTENT, SLEEP_FUNC, (caddr_t)un);
                ASSERT(pkt != NULL);

                makecommand(pkt, un->un_cmd_flags | FLAG_SILENT,
                    ATA_FLUSH_CACHE, 0, ADD_LBA_MODE, 0, NO_DATA_XFER, 0);

                pkt->pkt_comp = dcdintr;
                pkt->pkt_time = DCD_FLUSH_TIME;
                PKT_SET_BP(pkt, bp);

                bp->av_back = (struct buf *)pkt;
                bp->b_forw = NULL;
                bp->b_flags = B_BUSY;
                bp->b_error = 0;
                bp->b_edev = dev;
                bp->b_dev = cmpdev(dev);
                bp->b_bcount = 0;
                bp->b_blkno = 0;
                bp->b_un.b_addr = 0;
                bp->b_iodone = NULL;
                bp->b_list = NULL;
                bp->b_private = NULL;

                if ((flag & FKIOCTL) && dkc != NULL &&
                    dkc->dkc_callback != NULL) {
                        struct dk_callback *dkc2 = (struct dk_callback *)
                            kmem_zalloc(sizeof (*dkc2), KM_SLEEP);
                        bcopy(dkc, dkc2, sizeof (*dkc2));

                        bp->b_private = dkc2;
                        bp->b_iodone = dcdflushdone;
                        is_sync = 0;
                }

                (void) dcdstrategy(bp);

                i = 0;
                if (is_sync) {
                        i = biowait(bp);
                        (void) dcdflushdone(bp);
                }

                return (i);
        }
        default:
                break;
        }
        return (ENOTTY);
}


static int
dcdflushdone(struct buf *bp)
{
        struct dcd_disk *un = ddi_get_soft_state(dcd_state,
            DCDUNIT(bp->b_edev));
        struct dcd_pkt *pkt = BP_PKT(bp);
        struct dk_callback *dkc = bp->b_private;

        ASSERT(un != NULL);
        ASSERT(bp == un->un_sbufp);
        ASSERT(pkt != NULL);

        dcd_destroy_pkt(pkt);
        bp->av_back = NO_PKT_ALLOCATED;

        if (dkc != NULL) {
                ASSERT(bp->b_iodone != NULL);
                (*dkc->dkc_callback)(dkc->dkc_cookie, geterror(bp));
                kmem_free(dkc, sizeof (*dkc));
                bp->b_iodone = NULL;
                bp->b_private = NULL;
        }

        /*
         * Tell anybody who cares that the buffer is now free
         */
        mutex_enter(DCD_MUTEX);
        un->un_sbuf_busy = 0;
        cv_signal(&un->un_sbuf_cv);
        mutex_exit(DCD_MUTEX);
        return (0);
}

/*
 * dcdrunout:
 *      the callback function for resource allocation
 *
 * XXX it would be preferable that dcdrunout() scans the whole
 *      list for possible candidates for dcdstart(); this avoids
 *      that a bp at the head of the list whose request cannot be
 *      satisfied is retried again and again
 */
/*ARGSUSED*/
static int
dcdrunout(caddr_t arg)
{
        int serviced;
        struct dcd_disk *un;
        struct diskhd *dp;

        TRACE_1(TR_FAC_DADA, TR_DCDRUNOUT_START, "dcdrunout_start: arg 0x%p",
            arg);
        serviced = 1;

        un = (struct dcd_disk *)arg;
        dp = &un->un_utab;

        /*
         * We now support passing a structure to the callback
         * routine.
         */
        ASSERT(un != NULL);
        mutex_enter(DCD_MUTEX);
        if ((un->un_ncmds < un->un_throttle) && (dp->b_forw == NULL)) {
                dcdstart(un);
        }
        if (un->un_state == DCD_STATE_RWAIT) {
                serviced = 0;
        }
        mutex_exit(DCD_MUTEX);
        TRACE_1(TR_FAC_DADA, TR_DCDRUNOUT_END,
            "dcdrunout_end: serviced %d", serviced);
        return (serviced);
}


/*
 * This routine called to see whether unit is (still) there. Must not
 * be called when un->un_sbufp is in use, and must not be called with
 * an unattached disk. Soft state of disk is restored to what it was
 * upon entry- up to caller to set the correct state.
 *
 * We enter with the disk mutex held.
 */

/* ARGSUSED0 */
static int
dcd_unit_ready(dev_t dev)
{
#ifndef lint
        auto struct udcd_cmd dcmd, *com = &dcmd;
        auto struct dcd_cmd cmdblk;
#endif
        int error;
#ifndef lint
        GET_SOFT_STATE(dev);
#endif

        /*
         * Now that we protect the special buffer with
         * a mutex, we could probably do a mutex_tryenter
         * on it here and return failure if it were held...
         */

        error = 0;
        return (error);
}

/* ARGSUSED0 */
int
dcdioctl_cmd(dev_t devp, struct udcd_cmd *in, enum uio_seg cdbspace,
    enum uio_seg dataspace)
{

        struct buf *bp;
        struct  udcd_cmd *scmd;
        struct dcd_pkt *pkt;
        int     err, rw;
        caddr_t cdb;
        int     flags = 0;

        GET_SOFT_STATE(devp);

#ifdef lint
        part = part;
#endif

        /*
         * Is this a request to reset the bus?
         * if so, we need to do reseting.
         */

        if (in->udcd_flags & UDCD_RESET) {
                int flag = RESET_TARGET;
                err = dcd_reset(ROUTE, flag) ? 0: EIO;
                return (err);
        }

        scmd = in;


        /* Do some sanity checks */
        if (scmd->udcd_buflen <= 0) {
                if (scmd->udcd_flags & (UDCD_READ | UDCD_WRITE)) {
                        return (EINVAL);
                } else {
                        scmd->udcd_buflen = 0;
                }
        }

        /* Make a copy of the dcd_cmd passed  */
        cdb = kmem_zalloc(sizeof (struct dcd_cmd), KM_SLEEP);
        if (cdbspace == UIO_SYSSPACE) {
                flags |= FKIOCTL;
        }

        if (ddi_copyin((void *)scmd->udcd_cmd, cdb, sizeof (struct dcd_cmd),
            flags)) {
                kmem_free(cdb, sizeof (struct dcd_cmd));
                return (EFAULT);
        }
        scmd = (struct udcd_cmd *)kmem_alloc(sizeof (*scmd), KM_SLEEP);
        bcopy((caddr_t)in, (caddr_t)scmd, sizeof (*scmd));
        scmd->udcd_cmd = (struct dcd_cmd *)cdb;
        rw = (scmd->udcd_flags & UDCD_READ) ? B_READ: B_WRITE;


        /*
         * Get the special buffer
         */

        mutex_enter(DCD_MUTEX);
        while (un->un_sbuf_busy) {
                if (cv_wait_sig(&un->un_sbuf_cv, DCD_MUTEX) == 0) {
                        kmem_free(scmd->udcd_cmd, sizeof (struct dcd_cmd));
                        kmem_free((caddr_t)scmd, sizeof (*scmd));
                        mutex_exit(DCD_MUTEX);
                        return (EINTR);
                }
        }

        un->un_sbuf_busy = 1;
        bp  = un->un_sbufp;
        mutex_exit(DCD_MUTEX);


        /*
         * If we are going to do actual I/O, let physio do all the
         * things
         */
        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
            "dcdioctl_cmd : buflen %x\n", scmd->udcd_buflen);

        if (scmd->udcd_buflen) {
                auto struct iovec aiov;
                auto struct uio auio;
                struct uio *uio = &auio;

                bzero((caddr_t)&auio, sizeof (struct uio));
                bzero((caddr_t)&aiov, sizeof (struct iovec));

                aiov.iov_base = scmd->udcd_bufaddr;
                aiov.iov_len = scmd->udcd_buflen;

                uio->uio_iov = &aiov;
                uio->uio_iovcnt = 1;
                uio->uio_resid = scmd->udcd_buflen;
                uio->uio_segflg = dataspace;

                /*
                 * Let physio do the rest...
                 */
                bp->av_back = NO_PKT_ALLOCATED;
                bp->b_forw = (struct buf *)scmd;
                err = physio(dcdstrategy, bp, devp, rw, dcdudcdmin, uio);
        } else {
                /*
                 * We have to mimic what physio would do here.
                 */
                bp->av_back = NO_PKT_ALLOCATED;
                bp->b_forw = (struct buf *)scmd;
                bp->b_flags = B_BUSY | rw;
                bp->b_edev = devp;
                bp->b_dev = cmpdev(devp);
                bp->b_bcount = bp->b_blkno = 0;
                (void) dcdstrategy(bp);
                err = biowait(bp);
        }

done:
        if ((pkt = BP_PKT(bp)) != NULL) {
                bp->av_back = NO_PKT_ALLOCATED;
                /* we need to update the completion status of udcd command */
                in->udcd_resid = bp->b_resid;
                in->udcd_status_reg = SCBP_C(pkt);
                /* XXX: we need to give error_reg also */
                dcd_destroy_pkt(pkt);
        }
        /*
         * Tell anybody who cares that the buffer is now free
         */
        mutex_enter(DCD_MUTEX);
        un->un_sbuf_busy = 0;
        cv_signal(&un->un_sbuf_cv);
        mutex_exit(DCD_MUTEX);

        kmem_free(scmd->udcd_cmd, sizeof (struct dcd_cmd));
        kmem_free((caddr_t)scmd, sizeof (*scmd));
        return (err);
}

static void
dcdudcdmin(struct buf *bp)
{

#ifdef lint
        bp = bp;
#endif

}

/*
 * restart a cmd from timeout() context
 *
 * the cmd is expected to be in un_utab.b_forw. If this pointer is non-zero
 * a restart timeout request has been issued and no new timeouts should
 * be requested. b_forw is reset when the cmd eventually completes in
 * dcddone_and_mutex_exit()
 */
void
dcdrestart(void *arg)
{
        struct dcd_disk *un = (struct dcd_disk *)arg;
        struct buf *bp;
        int status;

        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG, "dcdrestart\n");

        mutex_enter(DCD_MUTEX);
        bp = un->un_utab.b_forw;
        if (bp) {
                un->un_ncmds++;
                DCD_DO_KSTATS(un, kstat_waitq_to_runq, bp);
        }


        if (bp) {
                struct dcd_pkt *pkt = BP_PKT(bp);

                mutex_exit(DCD_MUTEX);

                pkt->pkt_flags = 0;

                if ((status = dcd_transport(pkt)) != TRAN_ACCEPT) {
                        mutex_enter(DCD_MUTEX);
                        DCD_DO_KSTATS(un, kstat_runq_back_to_waitq, bp);
                        un->un_ncmds--;
                        if (status == TRAN_BUSY) {
                                /* XXX : To be checked */
                                /*
                                 * if (un->un_throttle > 1) {
                                 *      ASSERT(un->un_ncmds >= 0);
                                 *      un->un_throttle = un->un_ncmds;
                                 * }
                                 */
                                un->un_reissued_timeid =
                                    timeout(dcdrestart, (caddr_t)un,
                                    DCD_BSY_TIMEOUT/500);
                                mutex_exit(DCD_MUTEX);
                                return;
                        }
                        DCD_DO_ERRSTATS(un, dcd_transerrs);
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "dcdrestart transport failed (%x)\n", status);
                        bp->b_resid = bp->b_bcount;
                        SET_BP_ERROR(bp, EIO);

                        DCD_DO_KSTATS(un, kstat_waitq_exit, bp);
                        un->un_reissued_timeid = 0L;
                        dcddone_and_mutex_exit(un, bp);
                        return;
                }
                mutex_enter(DCD_MUTEX);
        }
        un->un_reissued_timeid = 0L;
        mutex_exit(DCD_MUTEX);
        DAD_DEBUG(DCD_DEVINFO, dcd_label, DCD_DEBUG, "dcdrestart done\n");
}

/*
 * This routine gets called to reset the throttle to its saved
 * value wheneven we lower the throttle.
 */
void
dcd_reset_throttle(caddr_t arg)
{
        struct dcd_disk *un = (struct dcd_disk *)arg;
        struct diskhd *dp;

        mutex_enter(DCD_MUTEX);
        dp = &un->un_utab;

        /*
         * start any commands that didn't start while throttling.
         */
        if (dp->b_actf && (un->un_ncmds < un->un_throttle) &&
            (dp->b_forw == NULL)) {
                dcdstart(un);
        }
        mutex_exit(DCD_MUTEX);
}


/*
 * This routine handles the case when a TRAN_BUSY is
 * returned by HBA.
 *
 * If there are some commands already in the transport, the
 * bp can be put back on queue and it will
 * be retried when the queue is emptied after command
 * completes. But if there is no command in the tranport
 * and it still return busy, we have to retry the command
 * after some time like 10ms.
 */
/* ARGSUSED0 */
static void
dcd_handle_tran_busy(struct buf *bp, struct diskhd *dp, struct dcd_disk *un)
{
        ASSERT(mutex_owned(DCD_MUTEX));


        if (dp->b_forw == NULL || dp->b_forw == bp) {
                dp->b_forw = bp;
        } else if (dp->b_forw != bp) {
                bp->b_actf = dp->b_actf;
                dp->b_actf = bp;

        }
        if (!un->un_reissued_timeid) {
                un->un_reissued_timeid =
                    timeout(dcdrestart, (caddr_t)un, DCD_BSY_TIMEOUT/500);
        }
}

static int
dcd_write_deviceid(struct dcd_disk *un)
{

        int     status;
        diskaddr_t blk;
        struct udcd_cmd ucmd;
        struct dcd_cmd cdb;
        struct dk_devid *dkdevid;
        uint_t *ip, chksum;
        int     i;
        dev_t   dev;

        mutex_exit(DCD_MUTEX);
        if (cmlb_get_devid_block(un->un_dklbhandle, &blk, 0)) {
                mutex_enter(DCD_MUTEX);
                return (EINVAL);
        }
        mutex_enter(DCD_MUTEX);

        /* Allocate the buffer */
        dkdevid = kmem_zalloc(un->un_secsize, KM_SLEEP);

        /* Fill in the revision */
        dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB;
        dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB;

        /* Copy in the device id */
        bcopy(un->un_devid, &dkdevid->dkd_devid,
            ddi_devid_sizeof(un->un_devid));

        /* Calculate the chksum */
        chksum = 0;
        ip = (uint_t *)dkdevid;
        for (i = 0; i < ((un->un_secsize - sizeof (int))/sizeof (int)); i++)
                chksum ^= ip[i];

        /* Fill in the checksum */
        DKD_FORMCHKSUM(chksum, dkdevid);

        (void) bzero((caddr_t)&ucmd, sizeof (ucmd));
        (void) bzero((caddr_t)&cdb, sizeof (struct dcd_cmd));

        if ((un->un_dp->options & DMA_SUPPORTTED) == DMA_SUPPORTTED) {
                cdb.cmd = ATA_WRITE_DMA;
        } else {
                if (un->un_dp->options & BLOCK_MODE)
                        cdb.cmd = ATA_WRITE_MULTIPLE;
                else
                        cdb.cmd = ATA_WRITE;
        }
        cdb.size = un->un_secsize;
        cdb.sector_num.lba_num = blk;
        cdb.address_mode = ADD_LBA_MODE;
        cdb.direction = DATA_WRITE;

        ucmd.udcd_flags = UDCD_WRITE;
        ucmd.udcd_cmd =  &cdb;
        ucmd.udcd_bufaddr = (caddr_t)dkdevid;
        ucmd.udcd_buflen = un->un_secsize;
        ucmd.udcd_flags |= UDCD_SILENT;
        dev = makedevice(ddi_driver_major(DCD_DEVINFO),
            ddi_get_instance(DCD_DEVINFO) << DCDUNIT_SHIFT);
        mutex_exit(DCD_MUTEX);
        status = dcdioctl_cmd(dev, &ucmd, UIO_SYSSPACE, UIO_SYSSPACE);
        mutex_enter(DCD_MUTEX);

        kmem_free(dkdevid, un->un_secsize);
        return (status);
}

static int
dcd_read_deviceid(struct dcd_disk *un)
{
        int status;
        diskaddr_t blk;
        struct udcd_cmd ucmd;
        struct dcd_cmd cdb;
        struct dk_devid *dkdevid;
        uint_t *ip;
        int chksum;
        int i, sz;
        dev_t dev;

        mutex_exit(DCD_MUTEX);
        if (cmlb_get_devid_block(un->un_dklbhandle, &blk, 0)) {
                mutex_enter(DCD_MUTEX);
                return (EINVAL);
        }
        mutex_enter(DCD_MUTEX);

        dkdevid = kmem_alloc(un->un_secsize, KM_SLEEP);

        (void) bzero((caddr_t)&ucmd, sizeof (ucmd));
        (void) bzero((caddr_t)&cdb, sizeof (cdb));

        if ((un->un_dp->options & DMA_SUPPORTTED) == DMA_SUPPORTTED) {
                cdb.cmd = ATA_READ_DMA;
        } else {
                if (un->un_dp->options & BLOCK_MODE)
                        cdb.cmd = ATA_READ_MULTIPLE;
                else
                        cdb.cmd = ATA_READ;
        }
        cdb.size = un->un_secsize;
        cdb.sector_num.lba_num = blk;
        cdb.address_mode = ADD_LBA_MODE;
        cdb.direction = DATA_READ;

        ucmd.udcd_flags = UDCD_READ;
        ucmd.udcd_cmd =  &cdb;
        ucmd.udcd_bufaddr = (caddr_t)dkdevid;
        ucmd.udcd_buflen = un->un_secsize;
        ucmd.udcd_flags |= UDCD_SILENT;
        dev = makedevice(ddi_driver_major(DCD_DEVINFO),
            ddi_get_instance(DCD_DEVINFO) << DCDUNIT_SHIFT);
        mutex_exit(DCD_MUTEX);
        status = dcdioctl_cmd(dev, &ucmd, UIO_SYSSPACE, UIO_SYSSPACE);
        mutex_enter(DCD_MUTEX);

        if (status != 0) {
                kmem_free((caddr_t)dkdevid, un->un_secsize);
                return (status);
        }

        /* Validate the revision */

        if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) ||
            (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) {
                kmem_free((caddr_t)dkdevid, un->un_secsize);
                return (EINVAL);
        }

        /* Calculate the checksum */
        chksum = 0;
        ip = (uint_t *)dkdevid;
        for (i = 0; i < ((un->un_secsize - sizeof (int))/sizeof (int)); i++)
                chksum ^= ip[i];

        /* Compare the checksums */

        if (DKD_GETCHKSUM(dkdevid) != chksum) {
                kmem_free((caddr_t)dkdevid, un->un_secsize);
                return (EINVAL);
        }

        /* VAlidate the device id */
        if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) {
                kmem_free((caddr_t)dkdevid, un->un_secsize);
                return (EINVAL);
        }

        /* return a copy of the device id */
        sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid);
        un->un_devid = (ddi_devid_t)kmem_alloc(sz, KM_SLEEP);
        bcopy(&dkdevid->dkd_devid, un->un_devid, sz);
        kmem_free((caddr_t)dkdevid, un->un_secsize);

        return (0);
}

/*
 * Return the device id for the device.
 * 1. If the device ID exists then just return it - nothing to do in that case.
 * 2. Build one from the drives model number and serial number.
 * 3. If there is a problem in building it from serial/model #, then try
 * to read it from the acyl region of the disk.
 * Note: If this function is unable to return a valid ID then the calling
 * point will invoke the routine to create a fabricated ID ans stor it on the
 * acyl region of the disk.
 */
static ddi_devid_t
dcd_get_devid(struct dcd_disk *un)
{
        int             rc;

        /* If already registered, return that value */
        if (un->un_devid != NULL)
                return (un->un_devid);

        /* Build a devid from model and serial number, if present */
        rc = dcd_make_devid_from_serial(un);

        if (rc != DDI_SUCCESS) {
                /* Read the devid from the disk. */
                if (dcd_read_deviceid(un))
                        return (NULL);
        }

        (void) ddi_devid_register(DCD_DEVINFO, un->un_devid);
        return (un->un_devid);
}


static ddi_devid_t
dcd_create_devid(struct dcd_disk *un)
{
        if (ddi_devid_init(DCD_DEVINFO, DEVID_FAB, 0, NULL, (ddi_devid_t *)
            &un->un_devid) == DDI_FAILURE)
                return (NULL);

        if (dcd_write_deviceid(un)) {
                ddi_devid_free(un->un_devid);
                un->un_devid = NULL;
                return (NULL);
        }

        (void) ddi_devid_register(DCD_DEVINFO, un->un_devid);
        return (un->un_devid);
}

/*
 * Build a devid from the model and serial number, if present
 * Return DDI_SUCCESS or DDI_FAILURE.
 */
static int
dcd_make_devid_from_serial(struct dcd_disk *un)
{
        int     rc = DDI_SUCCESS;
        char    *hwid;
        char    *model;
        int     model_len;
        char    *serno;
        int     serno_len;
        int     total_len;

        /* initialize the model and serial number information */
        model = un->un_dcd->dcd_ident->dcd_model;
        model_len = DCD_MODEL_NUMBER_LENGTH;
        serno = un->un_dcd->dcd_ident->dcd_drvser;
        serno_len = DCD_SERIAL_NUMBER_LENGTH;

        /* Verify the model and serial number */
        dcd_validate_model_serial(model, &model_len, model_len);
        if (model_len == 0) {
                rc = DDI_FAILURE;
                goto out;
        }
        dcd_validate_model_serial(serno, &serno_len, serno_len);
        if (serno_len == 0) {
                rc = DDI_FAILURE;
                goto out;
        }

        /*
         * The device ID will be concatenation of the model number,
         * the '=' separator, the serial number. Allocate
         * the string and concatenate the components.
         */
        total_len = model_len + 1 + serno_len;
        hwid = kmem_alloc(total_len, KM_SLEEP);
        bcopy((caddr_t)model, (caddr_t)hwid, model_len);
        bcopy((caddr_t)"=", (caddr_t)&hwid[model_len], 1);
        bcopy((caddr_t)serno, (caddr_t)&hwid[model_len + 1], serno_len);

        /* Initialize the device ID, trailing NULL not included */
        rc = ddi_devid_init(DCD_DEVINFO, DEVID_ATA_SERIAL, total_len,
            hwid, (ddi_devid_t *)&un->un_devid);

        /* Free the allocated string */
        kmem_free(hwid, total_len);

out:    return (rc);
}

/*
 * Test for a valid model or serial number. Assume that a valid representation
 * contains at least one character that is neither a space, 0 digit, or NULL.
 * Trim trailing blanks and NULLS from returned length.
 */
static void
dcd_validate_model_serial(char *str, int *retlen, int totallen)
{
        char            ch;
        boolean_t       ret = B_FALSE;
        int             i;
        int             tb;

        for (i = 0, tb = 0; i < totallen; i++) {
                ch = *str++;
                if ((ch != ' ') && (ch != '\0') && (ch != '0'))
                        ret = B_TRUE;
                if ((ch == ' ') || (ch == '\0'))
                        tb++;
                else
                        tb = 0;
        }

        if (ret == B_TRUE) {
                /* Atleast one non 0 or blank character. */
                *retlen = totallen - tb;
        } else {
                *retlen = 0;
        }
}

#ifndef lint
void
clean_print(dev_info_t *dev, char *label, uint_t level,
    char *title, char *data, int len)
{
        int     i;
        char    buf[256];

        (void) sprintf(buf, "%s:", title);
        for (i = 0; i < len; i++) {
                (void) sprintf(&buf[strlen(buf)], "0x%x ", (data[i] & 0xff));
        }
        (void) sprintf(&buf[strlen(buf)], "\n");

        dcd_log(dev, label, level, "%s", buf);
}
#endif /* Not lint */

#ifndef lint
/*
 * Print a piece of inquiry data- cleaned up for non-printable characters
 * and stopping at the first space character after the beginning of the
 * passed string;
 */

void
inq_fill(char *p, int l, char *s)
{
        unsigned i = 0;
        char c;

        while (i++ < l) {
                if ((c = *p++) < ' ' || c >= 0177) {
                        c = '*';
                } else if (i != 1 && c == ' ') {
                        break;
                }
                *s++ = c;
        }
        *s++ = 0;
}
#endif /* Not lint */

char *
dcd_sname(uchar_t status)
{
        switch (status & STATUS_ATA_MASK) {
        case STATUS_GOOD:
                return ("good status");

        case STATUS_ATA_BUSY:
                return ("busy");

        default:
                return ("<unknown status>");
        }
}

/* ARGSUSED0 */
char *
dcd_rname(int reason)
{
        static char *rnames[] = {
                "cmplt",
                "incomplete",
                "dma_derr",
                "tran_err",
                "reset",
                "aborted",
                "timeout",
                "data_ovr",
        };
        if (reason > CMD_DATA_OVR) {
                return ("<unknown reason>");
        } else {
                return (rnames[reason]);
        }
}



/* ARGSUSED0 */
int
dcd_check_wp(dev_t dev)
{

        return (0);
}

/*
 * Create device error kstats
 */
static int
dcd_create_errstats(struct dcd_disk *un, int instance)
{

        char kstatname[KSTAT_STRLEN];

        if (un->un_errstats == (kstat_t *)0) {
                (void) sprintf(kstatname, "dad%d,error", instance);
                un->un_errstats = kstat_create("daderror", instance, kstatname,
                    "device_error", KSTAT_TYPE_NAMED,
                    sizeof (struct dcd_errstats)/ sizeof (kstat_named_t),
                    KSTAT_FLAG_PERSISTENT);

                if (un->un_errstats) {
                        struct dcd_errstats *dtp;

                        dtp = (struct dcd_errstats *)un->un_errstats->ks_data;
                        kstat_named_init(&dtp->dcd_softerrs, "Soft Errors",
                            KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_harderrs, "Hard Errors",
                            KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_transerrs,
                            "Transport Errors", KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_model, "Model",
                            KSTAT_DATA_CHAR);
                        kstat_named_init(&dtp->dcd_revision, "Revision",
                            KSTAT_DATA_CHAR);
                        kstat_named_init(&dtp->dcd_serial, "Serial No",
                            KSTAT_DATA_CHAR);
                        kstat_named_init(&dtp->dcd_capacity, "Size",
                            KSTAT_DATA_ULONGLONG);
                        kstat_named_init(&dtp->dcd_rq_media_err, "Media Error",
                            KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_rq_ntrdy_err,
                            "Device Not Ready", KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_rq_nodev_err, " No Device",
                            KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_rq_recov_err, "Recoverable",
                            KSTAT_DATA_UINT32);
                        kstat_named_init(&dtp->dcd_rq_illrq_err,
                            "Illegal Request", KSTAT_DATA_UINT32);

                        un->un_errstats->ks_private = un;
                        un->un_errstats->ks_update = nulldev;
                        kstat_install(un->un_errstats);

                        (void) strncpy(&dtp->dcd_model.value.c[0],
                            un->un_dcd->dcd_ident->dcd_model, 16);
                        (void) strncpy(&dtp->dcd_serial.value.c[0],
                            un->un_dcd->dcd_ident->dcd_drvser, 16);
                        (void) strncpy(&dtp->dcd_revision.value.c[0],
                            un->un_dcd->dcd_ident->dcd_fw, 8);
                        dtp->dcd_capacity.value.ui64 =
                            (uint64_t)((uint64_t)un->un_diskcapacity *
                            (uint64_t)un->un_lbasize);
                }
        }
        return (0);
}


/*
 * This has been moved from DADA layer as this does not do anything other than
 * retrying the command when it is busy or it does not complete
 */
int
dcd_poll(struct dcd_pkt *pkt)
{
        int     busy_count, rval = -1, savef;
        clock_t savet;
        void    (*savec)();


        /*
         * Save old flags
         */
        savef = pkt->pkt_flags;
        savec = pkt->pkt_comp;
        savet = pkt->pkt_time;

        pkt->pkt_flags |= FLAG_NOINTR;


        /*
         * Set the Pkt_comp to NULL
         */

        pkt->pkt_comp = 0;

        /*
         * Set the Pkt time for the polled command
         */
        if (pkt->pkt_time == 0) {
                pkt->pkt_time = DCD_POLL_TIMEOUT;
        }


        /* Now transport the command */
        for (busy_count = 0; busy_count < dcd_poll_busycnt; busy_count++) {
                if ((rval = dcd_transport(pkt)) == TRAN_ACCEPT) {
                        if (pkt->pkt_reason == CMD_INCOMPLETE &&
                            pkt->pkt_state == 0) {
                                delay(100);
                        } else if (pkt->pkt_reason  == CMD_CMPLT) {
                                rval = 0;
                                break;
                        }
                }
                if (rval == TRAN_BUSY)  {
                        delay(100);
                        continue;
                }
        }

        pkt->pkt_flags = savef;
        pkt->pkt_comp = savec;
        pkt->pkt_time = savet;
        return (rval);
}


void
dcd_translate(struct dadkio_status32 *statp, struct udcd_cmd *cmdp)
{
        if (cmdp->udcd_status_reg & STATUS_ATA_BUSY)
                statp->status = DADKIO_STAT_NOT_READY;
        else if (cmdp->udcd_status_reg & STATUS_ATA_DWF)
                statp->status = DADKIO_STAT_HARDWARE_ERROR;
        else if (cmdp->udcd_status_reg & STATUS_ATA_CORR)
                statp->status = DADKIO_STAT_SOFT_ERROR;
        else if (cmdp->udcd_status_reg & STATUS_ATA_ERR) {
                /*
                 * The error register is valid only when BSY and DRQ not set
                 * Assumed that HBA has checked this before it gives the data
                 */
                if (cmdp->udcd_error_reg & ERR_AMNF)
                        statp->status = DADKIO_STAT_NOT_FORMATTED;
                else if (cmdp->udcd_error_reg & ERR_TKONF)
                        statp->status = DADKIO_STAT_NOT_FORMATTED;
                else if (cmdp->udcd_error_reg & ERR_ABORT)
                        statp->status = DADKIO_STAT_ILLEGAL_REQUEST;
                else if (cmdp->udcd_error_reg & ERR_IDNF)
                        statp->status = DADKIO_STAT_NOT_FORMATTED;
                else if (cmdp->udcd_error_reg & ERR_UNC)
                        statp->status = DADKIO_STAT_BUS_ERROR;
                else if (cmdp->udcd_error_reg & ERR_BBK)
                        statp->status = DADKIO_STAT_MEDIUM_ERROR;
        } else
                statp->status = DADKIO_STAT_NO_ERROR;
}

static void
dcd_flush_cache(struct dcd_disk *un)
{
        struct dcd_pkt *pkt;
        int retry_count;


        if ((pkt = dcd_init_pkt(ROUTE, NULL, NULL,
            (uint32_t)sizeof (struct dcd_cmd), 2, PP_LEN,
            PKT_CONSISTENT, NULL_FUNC, NULL)) == NULL) {
                return;
        }

        makecommand(pkt, 0, ATA_FLUSH_CACHE, 0, ADD_LBA_MODE, 0,
            NO_DATA_XFER, 0);

        /*
         * Send the command. There are chances it might fail on some
         * disks since it is not a mandatory command as per ata-4. Try
         * 3 times if it fails. The retry count has been randomly selected.
         * There is a need for retry since as per the spec FLUSH CACHE can fail
         * as a result of unrecoverable error encountered during execution
         * of writing data and subsequent command should continue flushing
         * cache.
         */
        for (retry_count = 0; retry_count < 3; retry_count++) {
                /*
                 * Set the packet fields.
                 */
                pkt->pkt_comp = 0;
                pkt->pkt_time = DCD_POLL_TIMEOUT;
                pkt->pkt_flags |= FLAG_FORCENOINTR;
                pkt->pkt_flags |= FLAG_NOINTR;
                if (dcd_transport(pkt) == TRAN_ACCEPT) {
                        if (pkt->pkt_reason  == CMD_CMPLT) {
                                break;
                        }
                }
                /*
                 * Note the wait time value of 100ms is same as in the
                 * dcd_poll routine.
                 */
                drv_usecwait(1000000);
        }
        (void) dcd_destroy_pkt(pkt);
}

static int
dcd_send_lb_rw_cmd(dev_info_t *devi, void *bufaddr,
    diskaddr_t start_block, size_t reqlength, uchar_t cmd)
{
        struct dcd_pkt *pkt;
        struct buf *bp;
        diskaddr_t real_addr = start_block;
        size_t buffer_size = reqlength;
        uchar_t command, tmp;
        int i, rval = 0;
        struct dcd_disk *un;

        un = ddi_get_soft_state(dcd_state, ddi_get_instance(devi));
        if (un == NULL)
                return (ENXIO);

        bp = dcd_alloc_consistent_buf(ROUTE, (struct buf *)NULL,
            buffer_size, B_READ, NULL_FUNC, NULL);
        if (!bp) {
                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                    "no bp for disk label\n");
                return (ENOMEM);
        }

        pkt = dcd_init_pkt(ROUTE, (struct dcd_pkt *)NULL,
            bp, (uint32_t)sizeof (struct dcd_cmd), 2, PP_LEN,
            PKT_CONSISTENT, NULL_FUNC, NULL);

        if (!pkt) {
                dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                    "no memory for disk label\n");
                dcd_free_consistent_buf(bp);
                return (ENOMEM);
        }

        if (cmd == TG_READ) {
                bzero(bp->b_un.b_addr, buffer_size);
                tmp = DATA_READ;
        } else {
                bcopy((caddr_t)bufaddr, bp->b_un.b_addr, buffer_size);
                tmp = DATA_WRITE;
        }

        mutex_enter(DCD_MUTEX);
        if ((un->un_dp->options & DMA_SUPPORTTED) == DMA_SUPPORTTED) {
                if (cmd == TG_READ) {
                        command = ATA_READ_DMA;
                } else {
                        command = ATA_WRITE_DMA;
                }
        } else {
                if (cmd == TG_READ) {
                        if (un->un_dp->options & BLOCK_MODE)
                                command = ATA_READ_MULTIPLE;
                        else
                                command = ATA_READ;
                } else {
                        if (un->un_dp->options & BLOCK_MODE)
                                command = ATA_READ_MULTIPLE;
                        else
                                command = ATA_WRITE;
                }
        }
        mutex_exit(DCD_MUTEX);
        (void) makecommand(pkt, 0, command, real_addr, ADD_LBA_MODE,
            buffer_size, tmp, 0);

        for (i = 0; i < 3; i++) {
                if (dcd_poll(pkt) || SCBP_C(pkt) != STATUS_GOOD ||
                    (pkt->pkt_state & STATE_XFERRED_DATA) == 0 ||
                    (pkt->pkt_resid != 0)) {
                        DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                            "Status %x, state %x, resid %lx\n",
                            SCBP_C(pkt), pkt->pkt_state, pkt->pkt_resid);
                        rval = EIO;
                } else {
                        break;
                }
        }

        if (rval != 0) {
                dcd_destroy_pkt(pkt);
                dcd_free_consistent_buf(bp);
                return (EIO);
        }

        if (cmd == TG_READ) {
                bcopy(bp->b_un.b_addr, bufaddr, reqlength);
                rval = 0;
        }

        dcd_destroy_pkt(pkt);
        dcd_free_consistent_buf(bp);
        return (rval);
}

static int dcd_compute_dk_capacity(struct dcd_device *devp,
    diskaddr_t *capacity)
{
        diskaddr_t cap;
        diskaddr_t no_of_lbasec;

        cap = devp->dcd_ident->dcd_fixcyls *
            devp->dcd_ident->dcd_heads *
            devp->dcd_ident->dcd_sectors;
        no_of_lbasec = devp->dcd_ident->dcd_addrsec[1];
        no_of_lbasec = no_of_lbasec << 16;
        no_of_lbasec = no_of_lbasec | devp->dcd_ident->dcd_addrsec[0];

        if (no_of_lbasec > cap) {
                cap = no_of_lbasec;
        }

        if (cap != ((uint32_t)-1))
                *capacity = cap;
        else
                return (EINVAL);
        return (0);
}

/*ARGSUSED5*/
static int
dcd_lb_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
    diskaddr_t start_block, size_t reqlength, void *tg_cookie)
{
        if (cmd != TG_READ && cmd != TG_WRITE)
                return (EINVAL);

        return (dcd_send_lb_rw_cmd(devi, bufaddr, start_block,
            reqlength, cmd));
}

static int
dcd_lb_getphygeom(dev_info_t *devi, cmlb_geom_t *phygeomp)
{
        struct dcd_device *devp;
        uint32_t no_of_lbasec, capacity, calculated_cylinders;

        devp = ddi_get_driver_private(devi);

        if ((devp->dcd_ident->dcd_config & ATAPI_DEVICE) == 0) {
                if (devp->dcd_ident->dcd_config & ATANON_REMOVABLE) {
                        phygeomp->g_ncyl = devp->dcd_ident->dcd_fixcyls - 2;
                        phygeomp->g_acyl = 2;
                        phygeomp->g_nhead = devp->dcd_ident->dcd_heads;
                        phygeomp->g_nsect = devp->dcd_ident->dcd_sectors;

                        no_of_lbasec = devp->dcd_ident->dcd_addrsec[1];
                        no_of_lbasec = no_of_lbasec << 16;
                        no_of_lbasec = no_of_lbasec |
                            devp->dcd_ident->dcd_addrsec[0];
                        capacity = devp->dcd_ident->dcd_fixcyls *
                            devp->dcd_ident->dcd_heads *
                            devp->dcd_ident->dcd_sectors;
                        if (no_of_lbasec > capacity) {
                                capacity = no_of_lbasec;
                                if (capacity > NUM_SECTORS_32G) {
                                        /*
                                         * if the capacity is greater than 32G,
                                         * then 255 is the sectors per track.
                                         * This should be good until 128G disk
                                         * capacity, which is the current ATA-4
                                         * limitation.
                                         */
                                        phygeomp->g_nsect = 255;
                                }

                                /*
                                 * If the disk capacity is >= 128GB then no. of
                                 * addressable sectors will be set to 0xfffffff
                                 * in the IDENTIFY info. In that case set the
                                 *  no. of pcyl to the Max. 16bit value.
                                 */

                                calculated_cylinders = (capacity) /
                                    (phygeomp->g_nhead * phygeomp->g_nsect);
                                if (calculated_cylinders >= USHRT_MAX) {
                                        phygeomp->g_ncyl = USHRT_MAX - 2;
                                } else {
                                        phygeomp->g_ncyl =
                                            calculated_cylinders - 2;
                                }
                        }

                        phygeomp->g_capacity = capacity;
                        phygeomp->g_intrlv = 0;
                        phygeomp->g_rpm = 5400;
                        phygeomp->g_secsize = devp->dcd_ident->dcd_secsiz;

                        return (0);
                } else
                        return (ENOTSUP);
        } else {
                return (EINVAL);
        }
}


/*ARGSUSED3*/
static int
dcd_lb_getinfo(dev_info_t *devi, int cmd,  void *arg, void *tg_cookie)
{
        struct dcd_disk *un;

        un = ddi_get_soft_state(dcd_state, ddi_get_instance(devi));

        if (un == NULL)
                return (ENXIO);

        switch (cmd) {
        case TG_GETPHYGEOM:
                return (dcd_lb_getphygeom(devi, (cmlb_geom_t *)arg));

        case TG_GETVIRTGEOM:
                return (-1);

        case TG_GETCAPACITY:
        case TG_GETBLOCKSIZE:
                mutex_enter(DCD_MUTEX);
                if (un->un_diskcapacity <= 0) {
                        mutex_exit(DCD_MUTEX);
                        dcd_log(DCD_DEVINFO, dcd_label, CE_WARN,
                            "invalid disk capacity\n");
                        return (EIO);
                }
                if (cmd == TG_GETCAPACITY)
                        *(diskaddr_t *)arg = un->un_diskcapacity;
                else
                        *(uint32_t *)arg = DEV_BSIZE;

                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG, "capacity %x\n",
                    un->un_diskcapacity);
                mutex_exit(DCD_MUTEX);
                return (0);

        case TG_GETATTR:
                mutex_enter(DCD_MUTEX);
                *(tg_attribute_t *)arg = un->un_tgattribute;
                DAD_DEBUG2(DCD_DEVINFO, dcd_label, DCD_DEBUG,
                    "media_is_writable %x\n",
                    un->un_tgattribute.media_is_writable);
                mutex_exit(DCD_MUTEX);
                return (0);
        default:
                return (ENOTTY);
        }
}