ib/ibnex/ibnex_hca.c

	ibnex_hca.c revision 1aae5cd0fbf4c2622e76b8be40ca23c7c1f78e2b
/*
 * 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) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/modctl.h>
#include <sys/taskq.h>
#include <sys/mdi_impldefs.h>
#include <sys/sunmdi.h>
#include <sys/sunpm.h>
#include <sys/ib/mgt/ibdm/ibdm_impl.h>
#include <sys/ib/ibnex/ibnex.h>
#include <sys/ib/ibnex/ibnex_devctl.h>
#include <sys/ib/ibtl/ibti.h>
#include <sys/ib/ibtl/impl/ibtl_ibnex.h>
#include <sys/file.h>
#include <sys/hwconf.h>
#include <sys/fs/dv_node.h>

void ibnex_handle_hca_attach(void *);
static int ibnex_hca_bus_config_one(dev_info_t *, void *,
        ddi_bus_config_op_t, uint_t *, dev_info_t **);

static ibnex_node_data_t *ibnex_get_cdip_info(dev_info_t *, char *,
        dev_info_t **, ibnex_node_type_t *);
static int ibnex_prom_devname_to_pkey_n_portnum(
        char *, ib_pkey_t *, uint8_t *);
static dev_info_t *ibnex_config_obp_args(dev_info_t *, char *);

extern int  ibnex_busctl(dev_info_t *,
            dev_info_t *, ddi_ctl_enum_t, void *, void *);
extern int  ibnex_map_fault(dev_info_t *,
            dev_info_t *, struct hat *, struct seg *,
            caddr_t, struct devpage *, pfn_t, uint_t, uint_t);
static int  ibnex_hca_bus_config(dev_info_t *, uint_t,
            ddi_bus_config_op_t, void *, dev_info_t **);
static int  ibnex_hca_bus_unconfig(dev_info_t *,
            uint_t, ddi_bus_config_op_t, void *);
extern dev_info_t   *ibnex_config_port_node(dev_info_t *, char *);
extern dev_info_t   *ibnex_config_obp_args(dev_info_t *, char *);
extern int      ibnex_ioc_bus_config_one(dev_info_t **, uint_t,
                ddi_bus_config_op_t, void *, dev_info_t **, int *);
extern int      ibnex_pseudo_config_one(
            ibnex_node_data_t *, char *, dev_info_t *);
extern void     ibnex_config_all_children(dev_info_t *);
extern void         ibnex_pseudo_initnodes(void);

extern int      ibnex_pseudo_mdi_config_one(int, void *, dev_info_t **,
                char *, char *);
extern int          ibnex_get_dip_from_guid(ib_guid_t, int,
                ib_pkey_t, dev_info_t **);
extern dev_info_t   *ibnex_commsvc_initnode(dev_info_t *,
                ibdm_port_attr_t *, int, int, ib_pkey_t, int *,
                int);
extern uint64_t     ibnex_str2hex(char *, int, int *);
extern int      ibnex_str2int(char *, int, int *);
extern void     ibnex_create_hcasvc_nodes(
                dev_info_t *, ibdm_port_attr_t *);
extern void     ibnex_create_port_nodes(
                dev_info_t *, ibdm_port_attr_t *);
extern void     ibnex_create_vppa_nodes(
                dev_info_t *, ibdm_port_attr_t *);
extern int      ibnex_get_pkey_commsvc_index_portnum(
                char *, int *, ib_pkey_t *, uint8_t *);

extern ibnex_t  ibnex;
extern int  ibnex_port_settling_time;

/*
 * The bus_ops structure defines the capabilities of HCA nexus driver.
 */
struct bus_ops ibnex_ci_busops = {
    BUSO_REV,
    nullbusmap,     /* bus_map */
    NULL,           /* bus_get_intrspec */
    NULL,           /* bus_add_intrspec */
    NULL,           /* bus_remove_intrspec */
    ibnex_map_fault,    /* Map Fault */
    ddi_no_dma_map,     /* DMA related entry points */
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    ibnex_busctl,       /* bus_ctl */
    ddi_bus_prop_op,    /* bus_prop_op */
    NULL,           /* bus_get_eventcookie  */
    NULL,           /* bus_add_eventcall    */
    NULL,           /* bus_remove_eventcall */
    NULL,           /* bus_post_event   */
    NULL,
    ibnex_hca_bus_config,   /* bus config */
    ibnex_hca_bus_unconfig  /* bus unconfig */
};

/*
 * ibnex_hca_bus_config()
 *
 * BUS_CONFIG_ONE:
 *  Enumerate the exact instance of the driver. Use the device node name
 *  to locate the exact instance.
 *  Query IBDM to find whether the hardware exits for the instance of the
 *  driver. If exists, create a device node and return NDI_SUCCESS.
 *
 * BUS_CONFIG_ALL:
 *  Enumerate all the instances of all the possible children (seen before
 *  and never seen before).
 *
 * BUS_CONFIG_DRIVER:
 *  Enumerate all the instances of a particular driver.
 */
static int
ibnex_hca_bus_config(dev_info_t *parent, uint_t flag,
    ddi_bus_config_op_t op, void *devname, dev_info_t **child)
{
    int         ret = IBNEX_SUCCESS, circ;
    char            *srvname, nameaddr[MAXNAMELEN];
    dev_info_t      *cdip;
    ibnex_node_data_t   *node_data;
    ibnex_port_node_t   *port_node;

    /*
     * In a normal case HCA is setup as a phci.
     * If an HCA is in maintenance mode, its phci is not set up
     * but the driver is attached to update the firmware. In this
     * case, do not configure the MPxIO clients.
     */
    if (mdi_component_is_phci(parent, NULL) == MDI_FAILURE) {
        if (op == BUS_CONFIG_ALL || op == BUS_CONFIG_DRIVER)
            return (NDI_SUCCESS);
        else
            return (NDI_FAILURE);
    }

    switch (op) {
    case BUS_CONFIG_ONE:
        IBTF_DPRINTF_L4("ibnex", "\thca_bus_config: CONFIG_ONE, "
            "parent %p", parent);
        ret = ibnex_hca_bus_config_one(
            parent, devname, op, &flag, child);
        break;

    case BUS_CONFIG_OBP_ARGS:
        mdi_devi_enter(parent, &circ);
        cdip = ibnex_config_obp_args(parent, devname);
        if (cdip) {
            /*
             * Boot case.
             * Special handling because the "devname"
             * format for the enumerated device is
             * different.
             */
            node_data = ddi_get_parent_data(cdip);
            port_node = &node_data->node_data.port_node;
            if (node_data->node_type ==
                IBNEX_VPPA_COMMSVC_NODE) {
                srvname =
                    ibnex.ibnex_vppa_comm_svc_names[
                    port_node->port_commsvc_idx];
                (void) snprintf(nameaddr, MAXNAMELEN,
                    "ibport@%x,%x,%s",
                    port_node->port_num,
                    port_node->port_pkey, srvname);
            }
            devname = (void *)nameaddr;
        } else {
            IBTF_DPRINTF_L2("ibnex", "\thca_bus_config: "
                "CONFIG_OBP_ARGS : invalid state!!");

            ret = IBNEX_FAILURE;
        }
        mdi_devi_exit(parent, circ);
        break;

    case BUS_CONFIG_ALL:
        IBTF_DPRINTF_L4("ibnex",
            "\thca_bus_config: CONFIG_ALL parent %p", parent);
        ibnex_config_all_children(parent);
        break;

    case BUS_CONFIG_DRIVER:
        IBTF_DPRINTF_L4("ibnex", "\thca_bus_config: "
            "CONFIG_DRIVER parent %p", parent);
        ibnex_config_all_children(parent);
        break;

    default:
        IBTF_DPRINTF_L4("ibnex", "\thca_bus_config: error");
        ret = IBNEX_FAILURE;
        break;
    }


    if (ret == IBNEX_SUCCESS) {
        if (op == BUS_CONFIG_OBP_ARGS)
            op = BUS_CONFIG_ONE;

        ret = ndi_busop_bus_config(
            parent, flag, op, devname, child, 0);
        IBTF_DPRINTF_L4("ibnex", "\thca_bus_config:"
            "ndi_busop_bus_config : retval %d", ret);
        return (ret);
    }

    return (NDI_FAILURE);
}

/*
 * ibnex_hca_bus_unconfig()
 *
 *  Unconfigure a particular device node or all instance of a device
 *  driver device or all children of IBnex
 */
static int
ibnex_hca_bus_unconfig(dev_info_t *parent,
    uint_t flag, ddi_bus_config_op_t op, void *device_name)
{

    if (ndi_busop_bus_unconfig(parent, flag, op, device_name) !=
        DDI_SUCCESS)
        return (DDI_FAILURE);

    if ((op == BUS_UNCONFIG_ALL || op == BUS_UNCONFIG_DRIVER) &&
        (flag & NDI_UNCONFIG)) {
        ibnex_node_data_t   *ndp;
        dev_info_t      *dip = NULL;
        major_t         major = (major_t)(uintptr_t)device_name;

        mutex_enter(&ibnex.ibnex_mutex);

        if (major == -1) {
            /*
             * HCA dip. When major number is -1 HCA is
             * going away cleanup all the port nodes.
             */
            for (ndp = ibnex.ibnex_port_node_head;
                ndp; ndp = ndp->node_next) {
                ibnex_port_node_t   *port_node;

                port_node = &ndp->node_data.port_node;
                if (port_node->port_pdip == parent) {
                    port_node->port_pdip = NULL;
                    ndp->node_dip = NULL;
                    ndp->node_state =
                        IBNEX_CFGADM_UNCONFIGURED;
                }
            }
        } else {
            /*
             * HCA dip. Cleanup only the port nodes that
             * match the major number.
             */
            for (ndp = ibnex.ibnex_port_node_head;
                ndp; ndp = ndp->node_next) {
                ibnex_port_node_t   *port_node;

                port_node = &ndp->node_data.port_node;
                dip = ndp->node_dip;
                if (dip && (ddi_driver_major(dip) ==
                    major) && port_node->port_pdip ==
                    parent) {
                    port_node->port_pdip = NULL;
                    ndp->node_dip = NULL;
                    ndp->node_state =
                        IBNEX_CFGADM_UNCONFIGURED;
                }
            }
        }
        mutex_exit(&ibnex.ibnex_mutex);
    }
    return (DDI_SUCCESS);
}

/*
 * ibnex_config_obp_args()
 *  Configures a particular port node for a IP over IB communication
 *  service.
 *  The format of the input string "devname" is
 *      port=x,pkey=y,protocol=ip,<wanboot options>
 *  Thr format of the node name created here is
 *      ibport@<Port#>,<pkey>,<service name>
 *  where pkey = 0 for port communication service nodes
 *  Returns "dev_info_t" of the "child" node just created
 *  NULL when failed to enumerate the child node
 *
 */
static dev_info_t *
ibnex_config_obp_args(dev_info_t *parent, char *devname)
{
    int         ii, index;
    int         rval, iter = 0;
    char            *temp;
    uint8_t         port_num;
    ib_guid_t       hca_guid, port_guid;
    ib_pkey_t       pkey;
    dev_info_t      *cdip;
    boolean_t       displayed = B_FALSE;
    ibdm_port_attr_t    *port_attr;

    IBTF_DPRINTF_L4("ibnex", "\tconfig_obp_args: %s", devname);

    /* Is this OBP node for IPoIB ? */
    temp = devname;
    do {
        temp = strstr(temp, ",protocol=ip");
        if (temp == NULL)
            break;

        if (strlen(devname) > (int)((temp - devname) + 12)) {
            if (temp[12] == ',')
                break;
        } else {
            break;
        }
        temp++;
    } while (temp);

    if (temp == NULL)
        return (NULL);
    if (ibnex_prom_devname_to_pkey_n_portnum(
        devname, &pkey, &port_num) != IBNEX_SUCCESS) {
        return (NULL);
    }
    for (index = 0; index < ibnex.ibnex_nvppa_comm_svcs; index++) {
        if (strcmp(ibnex.ibnex_vppa_comm_svc_names[index],
            "ipib") == 0) {
            break;
        }
    }

    hca_guid = ibtl_ibnex_hcadip2guid(parent);
    if ((port_attr = ibdm_ibnex_probe_hcaport(
        hca_guid, port_num)) == NULL) {
        IBTF_DPRINTF_L2("ibnex",
            "\tconfig_port_node: Port does not exist");
        return (NULL);
    }

    /* Wait until "port is up" */
    while (port_attr->pa_state != IBT_PORT_ACTIVE) {
        ibdm_ibnex_free_port_attr(port_attr);
        delay(drv_usectohz(10000));
        if ((port_attr = ibdm_ibnex_probe_hcaport(
            hca_guid, port_num)) == NULL) {
            return (NULL);
        }
        if (iter++ == 400) {
            if (displayed == B_FALSE) {
                cmn_err(CE_NOTE, "\tWaiting for Port %d "
                    "initialization", port_attr->pa_port_num);
                displayed = B_TRUE;
            }
        }
    }
    IBTF_DPRINTF_L4("ibnex", "\tPort is initialized");

    mutex_enter(&ibnex.ibnex_mutex);
    port_guid = port_attr->pa_port_guid;
    rval = ibnex_get_dip_from_guid(port_guid, index, pkey, &cdip);
    if (rval == IBNEX_SUCCESS && cdip != NULL) {
        IBTF_DPRINTF_L4("ibnex", "\tconfig_port_node: Node exists");
        mutex_exit(&ibnex.ibnex_mutex);
        ibdm_ibnex_free_port_attr(port_attr);
        return (cdip);
    }
    for (ii = 0; ii < port_attr->pa_npkeys; ii++) {
        if (pkey == port_attr->pa_pkey_tbl[ii].pt_pkey) {
            cdip = ibnex_commsvc_initnode(parent, port_attr,
                index, IBNEX_VPPA_COMMSVC_NODE, pkey, &rval,
                IBNEX_CFGADM_ENUMERATE);
            IBTF_DPRINTF_L5("ibnex",
                "\t ibnex_commsvc_initnode rval %x", rval);
            break;
        }
    }
    mutex_exit(&ibnex.ibnex_mutex);

    ibdm_ibnex_free_port_attr(port_attr);
    return (cdip);
}


/*
 * ibnex_prom_devname_to_pkey_n_portnum()
 *  Parses the device node name and extracts "PKEY" and "port#"
 *  Returns IBNEX_SUCCESS/IBNEX_FAILURE
 */
static int
ibnex_prom_devname_to_pkey_n_portnum(
    char *devname, ib_pkey_t *pkey, uint8_t *port)
{
    int ret = IBNEX_SUCCESS;
    char    *tmp, *tmp1;

    if ((tmp = strstr(devname, "port=")) != NULL) {
        if ((tmp = strchr(++tmp, '=')) != NULL)
            if ((tmp1 = strchr(++tmp, ',')) != NULL)
                *port = ibnex_str2int(tmp, (tmp1 - tmp), &ret);
    } else
        ret = IBNEX_FAILURE;

    if ((ret == IBNEX_SUCCESS) &&
        (tmp = strstr(devname, "pkey=")) != NULL) {
        if ((tmp = strchr(++tmp, '=')) != NULL)
            if ((tmp1 = strchr(++tmp, ',')) != NULL)
                *pkey = ibnex_str2hex(tmp, (tmp1 - tmp), &ret);
    } else
        ret = IBNEX_FAILURE;

    return (ret);
}

static ibnex_node_data_t *
ibnex_get_cdip_info(dev_info_t *parent,
    char *devname, dev_info_t **cdip, ibnex_node_type_t *type)
{
    char            *device_name, *cname = NULL, *caddr = NULL;
    int         len;
    ibnex_node_data_t   *node_data = NULL;

    len = strlen((char *)devname) + 1;
    device_name = i_ddi_strdup(devname, KM_SLEEP);
    i_ddi_parse_name(device_name, &cname, &caddr, NULL);

    IBTF_DPRINTF_L4("ibnex",
        "\tfind_child_dip: cname %s addr %s", cname, caddr);

    if (strncmp(cname, IBNEX_IOC_CNAME, 3) ==  0)
        *type = IBNEX_IOC_NODE;
    else if (strncmp(cname, IBNEX_IBPORT_CNAME, 3) ==  0)
        *type = IBNEX_HCA_CHILD_NODE;
    else
        *type = IBNEX_PSEUDO_NODE;

    *cdip = ndi_devi_findchild(parent, devname);

    IBTF_DPRINTF_L4("ibnex",
        "\tfind_child_dip: cdip %p type %x", *cdip, *type);

    if (*cdip)
        node_data = ddi_get_parent_data(*cdip);
    kmem_free(device_name, len);

    return (node_data);
}

static int
ibnex_hca_bus_config_one(dev_info_t *parent, void *devname,
ddi_bus_config_op_t op, uint_t *flag, dev_info_t **child)
{
    int         ret = IBNEX_SUCCESS, len, circ, need_bus_config;
    char            *device_name, *caddr, *cname;
    dev_info_t      *cdip;
    ibnex_node_data_t   *node_data;
    ibnex_node_type_t   node_type;
    int         index;
    uint8_t         port_num;
    ib_pkey_t       pkey;

    len = strlen((char *)devname) + 1;
    device_name = i_ddi_strdup(devname, KM_SLEEP);
    i_ddi_parse_name(device_name, &cname, &caddr, NULL);

    if (caddr == NULL || (strlen(caddr) == 0)) {
        IBTF_DPRINTF_L2("ibnex",
            "\thca_bus_config: Invalid device node address");
        kmem_free(device_name, len);
        return (IBNEX_FAILURE);
    }

    ndi_devi_enter(parent, &circ);
    node_data = ibnex_get_cdip_info(
        parent, devname, &cdip, &node_type);
    ndi_devi_exit(parent, circ);

    if (cdip) {
        if ((node_data) && (node_data->node_type ==
            IBNEX_PORT_COMMSVC_NODE)) {
            if (node_data->node_dip == NULL) {
                node_data->node_dip = cdip;
                node_data->node_data.port_node.port_pdip =
                    parent;
            }
        }
    }

    /*
     * If child dip is present, just return
     * from here.
     */
    if (cdip != NULL || (node_data != NULL &&
        node_data->node_dip != NULL)) {
        goto end;
    }

    switch (node_type) {

    case IBNEX_IOC_NODE:
        ret = ibnex_ioc_bus_config_one(&parent, *flag,
            op, devname, child, &need_bus_config);
        if (!need_bus_config) {
            kmem_free(device_name, len);
            return (ret);
        }
        break;

    case IBNEX_PSEUDO_NODE:
        ret = IBNEX_SUCCESS;
        mdi_devi_enter(parent, &circ);
        ibnex_pseudo_initnodes();
        mutex_enter(&ibnex.ibnex_mutex);
        ret = ibnex_pseudo_config_one(NULL,
            caddr, parent);
        mutex_exit(&ibnex.ibnex_mutex);
        mdi_devi_exit(parent, circ);
        break;

    default:
        if (ibnex_get_pkey_commsvc_index_portnum(devname,
            &index, &pkey, &port_num) != IBNEX_SUCCESS) {
            IBTF_DPRINTF_L2("ibnex",
                "\tconfig_port_node: Invalid Service Name");
            kmem_free(device_name, len);
            return (IBNEX_FAILURE);
        }

        if ((pkey != 0) && (port_num != 0)) {
            if (strcmp("ipib",
                ibnex.ibnex_vppa_comm_svc_names[index]) == 0) {
                IBTF_DPRINTF_L2("ibnex",
                    "Skipping IBD devices... ");
                break;
            }
        }

        ndi_devi_enter(parent, &circ);
        cdip = ibnex_config_port_node(parent, devname);
        if (cdip)
            ret = IBNEX_SUCCESS;
        else
            ret = IBNEX_FAILURE;
        ndi_devi_exit(parent, circ);
        break;
    }
end:
    if (node_type == IBNEX_HCA_CHILD_NODE) {
        /* Allows enumeration under PHCI */
        *flag |= NDI_MDI_FALLBACK;
    }
    kmem_free(device_name, len);
    return (ret);
}

void
ibnex_handle_hca_attach(void *cb_arg)
{
    ib_guid_t hca_guid  = *((ib_guid_t *)cb_arg);
    dev_info_t      *phci;
    int         ii, circ;
    ibdm_hca_list_t     *hca_list;

    IBTF_DPRINTF_L4("ibnex", "handle_hca_attach(%llx)", hca_guid);

    phci = ibtl_ibnex_hcaguid2dip(hca_guid);

    /*
     * Enumerate children of this HCA, port nodes,
     * VPPA & HCA_SVC nodes. Use ndi_devi_enter() for
     * locking. IB Nexus is enumerating the children
     * of HCA, not MPXIO clients.
     */
    ndi_devi_enter(phci, &circ);
    ibdm_ibnex_port_settle_wait(hca_guid, ibnex_port_settling_time);
    hca_list = ibdm_ibnex_get_hca_info_by_guid(hca_guid);
    if (hca_list == NULL) {
        ndi_devi_exit(phci, circ);
        kmem_free(cb_arg, sizeof (ib_guid_t));
        return;
    }
    ibnex_create_hcasvc_nodes(phci, hca_list->hl_hca_port_attr);
    for (ii = 0; ii < hca_list->hl_nports; ii++) {
        ibnex_create_port_nodes(phci, &hca_list->hl_port_attr[ii]);
        ibnex_create_vppa_nodes(phci, &hca_list->hl_port_attr[ii]);
    }
    ibdm_ibnex_free_hca_list(hca_list);
    ndi_devi_exit(phci, circ);
    kmem_free(cb_arg, sizeof (ib_guid_t));
}