dada/impl/dcd_hba.c

	dcd_hba.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/note.h>

/*
 * Generic SCSI Host Bus Adapter interface implementation
 */

#include <sys/dada/dada.h>

extern int dcd_options;

static kmutex_t dcd_hba_mutex;

kmutex_t    dcd_log_mutex;

struct dcd_hba_inst {
    dev_info_t  *inst_dip;
    dcd_hba_tran_t  *inst_hba_tran;
    struct dcd_hba_inst *inst_next;
    struct  dcd_hba_inst    *inst_prev;
};

static struct dcd_hba_inst  *dcd_hba_list   = NULL;
static struct dcd_hba_inst  *dcd_hba_list_tail = NULL;


_NOTE(READ_ONLY_DATA(dev_ops))

kmutex_t    dcd_flag_nointr_mutex;
kcondvar_t  dcd_flag_nointr_cv;


/*
 * Called from _init when loading the dcd module.
 */
void
dcd_initialize_hba_interface()
{
    mutex_init(&dcd_hba_mutex, NULL, MUTEX_DRIVER, NULL);
    mutex_init(&dcd_flag_nointr_mutex, NULL, MUTEX_DRIVER, NULL);
    cv_init(&dcd_flag_nointr_cv, NULL, CV_DRIVER, NULL);
    mutex_init(&dcd_log_mutex, NULL, MUTEX_DRIVER, NULL);
}

/*
 * Called from fini() when unloading the dcd module.
 */

void
dcd_uninitialize_hba_interface()
{
    mutex_destroy(&dcd_hba_mutex);
    cv_destroy(&dcd_flag_nointr_cv);
    mutex_destroy(&dcd_flag_nointr_mutex);
    mutex_destroy(&dcd_log_mutex);
}


/*
 * Called by an HBA from _init()
 */
/* ARGSUSED */
int
dcd_hba_init(struct modlinkage *modlp)
{

    return (0);
}


#ifdef NOTNEEDED
/* ARGSUSED */
int
dcd_hba_attach(dev_info_t *dip,
    ddi_dma_lim_t   *hba_lim,
    dcd_hba_tran_t  *hba_tran,
    int     flags,
    void        *hba_options)
{

    ddi_dma_attr_t      hba_dma_attr;

    bzero(&hba_dma_attr, sizeof (ddi_dma_attr_t));

    hba_dma_attr.dma_attr_burstsizes = hba_lim->dlim_burstsizes;
    hba_dma_attr.dma_attr_minxfer = hba_lim->dlim_minxfer;

    return (dcd_hba_attach_setup(dip, &hba_dma_attr, hba_tran, flags));
}
#endif


int
dcd_hba_attach(
    dev_info_t  *dip,
    ddi_dma_attr_t  *hba_dma_attr,
    dcd_hba_tran_t  *hba_tran,
    int     flags)
{

    struct dcd_hba_inst *elem;
    int         value;
    int         len;
    char            *prop_name;
    char            *errmsg =
        "dcd_hba_attach: cannott create property '%s' for %s%d\n";

    /*
     * Link this instance into the list
     */
    elem = kmem_alloc(sizeof (struct dcd_hba_inst), KM_SLEEP);

    elem->inst_dip = dip;
    elem->inst_hba_tran = hba_tran;

    mutex_enter(&dcd_hba_mutex);
    elem->inst_next = NULL;
    elem->inst_prev = dcd_hba_list_tail;

    if (dcd_hba_list == NULL) {
        dcd_hba_list = elem;
    }
    if (dcd_hba_list_tail) {
        dcd_hba_list_tail->inst_next = elem;
    }
    dcd_hba_list_tail = elem;
    mutex_exit(&dcd_hba_mutex);


    /*
     * Save all the improtant HBA information that must be accessed
     * later.
     */

    hba_tran->tran_hba_dip = dip;
    hba_tran->tran_hba_flags = flags;

    /*
     * Note: We only need dma_attr_minxfer and dma_attr_burstsize
     * from the DMA atrributes
     */

    hba_tran->tran_min_xfer = hba_dma_attr->dma_attr_minxfer;
    hba_tran->tran_min_burst_size =
            (1<<(ddi_ffs(hba_dma_attr->dma_attr_burstsizes)-1));
    hba_tran->tran_max_burst_size =
            (1<<(ddi_fls(hba_dma_attr->dma_attr_burstsizes)-1));


    prop_name = "dcd_options";
    len = 0;
    if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN, 0, prop_name,
        NULL, &len) == DDI_PROP_NOT_FOUND) {
        value = dcd_options;
        if (ddi_prop_update_int(DDI_MAJOR_T_UNKNOWN, dip,
            prop_name, value) != DDI_PROP_SUCCESS) {
            cmn_err(CE_CONT, errmsg, prop_name,
                ddi_get_name(dip), ddi_get_instance(dip));
        }
    }


    /*
     * XXX : This needs to be removed when code cleanup
     * ddi_set_driver_private(dip, (caddr_t)hba_tran);
     */
#ifdef DEBUG1
    printf("Called Set driver private with dip %x, tran %x\n",
        dip, hba_tran);
#endif

    return (DDI_SUCCESS);
}


/*
 * called by an HBA to detach an instance of the driver
 */

int
dcd_hba_detach(dev_info_t *dip)
{

    dcd_hba_tran_t  *hba;
    struct dcd_hba_inst     *elem;

    hba = ddi_get_driver_private(dip);
    ddi_set_driver_private(dip, NULL);
    ASSERT(hba != NULL);

    hba->tran_hba_dip = (dev_info_t *)NULL;
    hba->tran_hba_flags = 0;
    hba->tran_min_burst_size = (uchar_t)0;
    hba->tran_max_burst_size = (uchar_t)0;


    /*
     * Remove HBA instance from dcd_hba_list
     */

    mutex_enter(&dcd_hba_mutex);

    for (elem = dcd_hba_list; elem != (struct dcd_hba_inst *)NULL;
        elem = elem->inst_next) {
        if (elem->inst_dip == dip)
            break;
    }

    if (elem == (struct dcd_hba_inst *)NULL) {
        cmn_err(CE_NOTE, "dcd_hba_attach: Unknown HBA instance\n");
        mutex_exit(&dcd_hba_mutex);
    }

    if (elem == dcd_hba_list) {
        dcd_hba_list = elem->inst_next;
        dcd_hba_list->inst_prev = (struct dcd_hba_inst *)NULL;
    } else if (elem == dcd_hba_list_tail) {
        dcd_hba_list_tail = elem->inst_prev;
        dcd_hba_list_tail->inst_next = (struct dcd_hba_inst *)NULL;
    } else {
        elem->inst_prev->inst_next = elem->inst_next;
        elem->inst_next->inst_prev = elem->inst_prev;
    }
    mutex_exit(&dcd_hba_mutex);

    kmem_free(elem, sizeof (struct dcd_hba_inst));

    return (DDI_SUCCESS);
}

void
dcd_hba_fini()
{

}

/* ARGSUSED */
dcd_hba_tran_t *
dcd_hba_tran_alloc(
    dev_info_t  *dip,
    int     flags)
{

    return (kmem_zalloc(sizeof (dcd_hba_tran_t),
        (flags & DCD_HBA_CANSLEEP) ? KM_SLEEP: KM_NOSLEEP));
}


void
dcd_hba_tran_free(dcd_hba_tran_t    *hba_tran)
{

    kmem_free(hba_tran, sizeof (dcd_hba_tran_t));
}


/*
 * XXX: Do we really need the following routines.
 */

/*
 * private wrapper for dcd_pkt's allocated via scsi_hba_pkt_alloc
 */

struct dcd_pkt_wrapper {
    struct dcd_pkt  dcd_pkt;
    int     pkt_wrapper_len;
};

_NOTE(SCHEME_PROTECTS_DATA("unique per thread", dcd_pkt_wrapper))

/*
 * Round up all allocations so that we can gurentee
 * long-long alignment. This is the same alignment
 * provided by kmem_alloc().
 */

#define ROUNDUP(x)  (((x) + 0x07) & ~0x07)

/*
 * Called by an HBA to allocate a dcd_pkt
 */

/* ARGSUSED */
struct dcd_pkt *
dcd_hba_pkt_alloc(
    struct dcd_address  *ap,
    int         cmdlen,
    int         statuslen,
    int         tgtlen,
    int         hbalen,
    int         (*callback)(caddr_t arg),
    caddr_t         arg)
{

    struct dcd_pkt  *pkt;
    struct dcd_pkt_wrapper  *hba_pkt;
    caddr_t     p;
    int     pktlen;


    /*
     * Sanity check
     */
    if (callback != SLEEP_FUNC && callback != NULL_FUNC) {
        cmn_err(CE_PANIC, " dcd_hba_pkt_alloc: callback must be"
                " either SLEEP or NULL\n");
    }


    /*
     * Round up so everything gets allocated on long-word boundaries.
     */

    cmdlen = ROUNDUP(cmdlen);
    tgtlen = ROUNDUP(tgtlen);
    hbalen = ROUNDUP(hbalen);
    statuslen = ROUNDUP(statuslen);
    pktlen = sizeof (struct dcd_pkt_wrapper)
        + cmdlen + tgtlen +hbalen + statuslen;

    hba_pkt = kmem_zalloc(pktlen,
        (callback = SLEEP_FUNC) ? KM_SLEEP: KM_NOSLEEP);

    if (hba_pkt == NULL) {
        ASSERT(callback == NULL_FUNC);
        return (NULL);
    }

    /*
     * Set up or private info on this pkt
     */
    hba_pkt->pkt_wrapper_len = pktlen;
    pkt = &hba_pkt->dcd_pkt;
    p = (caddr_t)(hba_pkt + 1);

    /*
     * set up pointers to private data areas, cdb and status.
     */
    if (hbalen > 0) {
        pkt->pkt_ha_private = (ataopaque_t)p;
        p += hbalen;
    }

    if (tgtlen > 0) {
        pkt->pkt_private = (ataopaque_t)p;
        p += tgtlen;
    }

    if (statuslen > 0) {
        pkt->pkt_scbp = (uchar_t *)p;
        p += statuslen;
    }

    if (cmdlen > 0) {
        pkt->pkt_cdbp = (void *)p;
    }

    /*
     * Initialize the pkt's dcd_address
     */
    pkt->pkt_address = *ap;
#ifdef DEBUG1
    printf("a_target %x, a_lun %x, a_hba_tran %x\n",
        pkt->pkt_address.a_target, pkt->pkt_address.a_lun,
        pkt->pkt_address.a_hba_tran);
    printf("From address : a_target %x, a_lun %x, a_hba_tran %x\n",
        ap->a_target, ap->a_lun, ap->a_hba_tran);
    printf("Pkt %x\n", pkt);

#endif
    return (pkt);
}


/* ARGSUSED */
void
dcd_hba_pkt_free(
    struct dcd_address *ap,
    struct dcd_pkt     *pkt)
{

    kmem_free((struct dcd_pkt_wrapper *)pkt,
        ((struct dcd_pkt_wrapper *)pkt)->pkt_wrapper_len);
}


/*
 * Called by an HBA to map strings to capability indices
 */

int
dcd_hba_lookup_capstr(char      *capstr)
{

    /*
     * Capability strings, masking the '-' vs '_'.
     */
    static struct cap_strings {
        char *cap_string;
        int   cap_index;
    } cap_string[] = {
        { "dma-max",        DCD_CAP_DMA_MAX     },
        { "dma_max",        DCD_CAP_DMA_MAX     },
        { "ultraata",       DCD_CAP_ULTRA_ATA   },
        { "busmaster",      DCD_CAP_BUS_MASTER  },
        { "overlap",        DCD_CAP_OVERLAP     },
        { "parity",     DCD_CAP_PARITY      },
        { "sector-size",    DCD_CAP_SECTOR_SIZE },
        { "total-sectors",  DCD_CAP_TOTAL_SECTORS   },
        { "geometry",       DCD_CAP_GEOMETRY    },
        { "block-mode",     DCD_CAP_BLOCKMODE   },
        { "block-factor",   DCD_CAP_BLOCKFACTOR },
        { "dma-support",        DCD_CAP_DMA_SUPPORT },
        { "pio-support",    DCD_CAP_PIO_SUPPORT },
        { "lba-addressing", DCD_CAP_LBA_ADDRESSING  },
        { NULL, 0                   }
    };
    struct cap_strings *cp;

    for (cp = cap_string; cp->cap_string != NULL; cp++) {
        if (strcmp(cp->cap_string, capstr) == 0) {
            return (cp->cap_index);
        }
    }

    return (-1);
}