i86hvm/io/pv_sd.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <io/xdf_shell.h>

#include <sys/scsi/targets/sddef.h>

/*
 * We're emulating (and possibly layering on top of) sd devices, so xdf
 * disk unit mappings must match up with sd disk unit mappings'.
 */
#if !defined(XDF_PSHIFT)
#error "can't find definition for xdf unit mappings - XDF_PSHIFT"
#endif /* XDF_PSHIFT */

#if !defined(SDUNIT_SHIFT)
#error "can't find definition for cmdk unit mappings - SDUNIT_SHIFT"
#endif /* SDUNIT_SHIFT */

#if ((XDF_PSHIFT - SDUNIT_SHIFT) != 0)
#error "sd and xdf unit mappings don't match."
#endif /* ((XDF_PSHIFT - SDUNIT_SHIFT) != 0) */

extern const struct dev_ops sd_ops;
extern void         *sd_state;

/*
 * Globals required by xdf_shell.c
 */
const char      *xdfs_c_name = "sd";
const char      *xdfs_c_linkinfo = "PV SCSI Disk Driver";
void            **xdfs_c_hvm_ss = &sd_state;
const size_t        xdfs_c_hvm_ss_size = sizeof (struct sd_lun);
const struct dev_ops    *xdfs_c_hvm_dev_ops = &sd_ops;

const xdfs_h2p_map_t xdfs_c_h2p_map[] = {
    { "/pci@0,0/pci-ide@1,1/ide@0/sd@0,0", "/xpvd/xdf@768" },
    { "/pci@0,0/pci-ide@1,1/ide@0/sd@1,0", "/xpvd/xdf@832" },
    { "/pci@0,0/pci-ide@1,1/ide@1/sd@0,0", "/xpvd/xdf@5632" },
    { "/pci@0,0/pci-ide@1,1/ide@1/sd@1,0", "/xpvd/xdf@5696" },
    { NULL, 0 }
};

/*ARGSUSED*/
int
xdfs_c_ioctl(xdfs_state_t *xsp, dev_t dev, int part,
    int cmd, intptr_t arg, int flag, cred_t *credp, int *rvalp, boolean_t *done)
{
    dev_info_t  *dip = xsp->xdfss_dip;
    int     instance = ddi_get_instance(dip);
    int     rv;

    *done = B_TRUE;
    switch (cmd) {
    case DKIOCINFO: {
        struct dk_cinfo info;

        /* Pass on the ioctl request, save the response */
        if ((rv = ldi_ioctl(xsp->xdfss_tgt_lh[part],
            cmd, (intptr_t)&info, FKIOCTL, credp, rvalp)) != 0)
            return (rv);

        /* Update controller info */
        info.dki_cnum = ddi_get_instance(ddi_get_parent(dip));
        (void) strlcpy(info.dki_cname,
            ddi_get_name(ddi_get_parent(dip)), sizeof (info.dki_cname));

        /* Update unit info. */
        if (info.dki_ctype == DKC_VBD) {
            /*
             * Normally a real scsi device would report the
             * controller type as DKC_SCSI_CCS.  But we don't
             * emulate a real scsi controller.  (Which becomes
             * apparent if anyone tries to issue us a uscsi(7i)
             * command.) So instead of reporting DKC_SCSI_CCS,
             * we report DKC_UNKNOWN.
             */
            info.dki_ctype = DKC_UNKNOWN;
        }
        info.dki_unit = instance;
        (void) strlcpy(info.dki_dname,
            ddi_driver_name(dip), sizeof (info.dki_dname));
        info.dki_addr = 1;

        if (ddi_copyout(&info, (void *)arg, sizeof (info), flag))
            return (EFAULT);

        return (0);
    }
    default:
        *done = B_FALSE;
        return (0);
    } /* switch (cmd) */
    /*NOTREACHED*/
}

/*ARGSUSED*/
void
xdfs_c_devid_setup(xdfs_state_t *xsp)
{
    /*
     * Currently we only support cdrom devices, which don't have
     * devids associated with them.
     */
    ASSERT("cdrom devices don't have a devid");
}

/*ARGSUSED*/
int
xdfs_c_getpgeom(dev_info_t *dip, cmlb_geom_t *pgeom)
{
    /*
     * Currently we only support cdrom devices, which don't have
     * a physical geometry, so this routine should never get
     * invoked.
     */
    ASSERT("cdrom devices don't have any physical geometry");
    return (-1);
}

/*ARGSUSED*/
boolean_t
xdfs_c_bb_check(xdfs_state_t *xsp)
{
    /*
     * Currently we only support cdrom devices, which don't have
     * bad blocks, so this routine should never get invoked.
     */
    ASSERT("cdrom devices don't support bad block mappings");
    return (B_TRUE);
}

char *
xdfs_c_cmlb_node_type(xdfs_state_t *xsp)
{
    return (xsp->xdfss_tgt_is_cd ? DDI_NT_CD_CHAN : DDI_NT_BLOCK_CHAN);
}

/*ARGSUSED*/
int
xdfs_c_cmlb_alter_behavior(xdfs_state_t *xsp)
{
    return (0);
}

void
xdfs_c_attach(xdfs_state_t *xsp)
{
    dev_info_t  *dip = xsp->xdfss_dip;
    int     dtype = DTYPE_DIRECT;

    if (xsp->xdfss_tgt_is_cd) {
        dtype = DTYPE_RODIRECT;
        (void) ddi_prop_create(DDI_DEV_T_NONE, dip,
            DDI_PROP_CANSLEEP, "removable-media", NULL, 0);
    }

    /*
     * We use ndi_* instead of ddi_* because it will result in
     * INQUIRY_DEVICE_TYPE being a hardware property instead
     * or a driver property
     */
    (void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
        INQUIRY_DEVICE_TYPE, dtype);
}