/*
 * 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.
 */

/*
 * The Ethernet Over Infiniband Nexus driver is a bus nexus driver
 * that enumerates all the EoIB nodes.
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/kmem.h>
#include <sys/ksynch.h>
#include <sys/modctl.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>

#include <sys/ib/clients/eoib/enx_impl.h>

/*
 * Global per-instance EoIB Nexus data.  Only one instance
 * of EoIB Nexus is supported
 */
eibnx_t *enx_global_ss = NULL;

/*
 * Static function declarations
 */
static int eibnx_attach(dev_info_t *, ddi_attach_cmd_t);
static int eibnx_detach(dev_info_t *, ddi_detach_cmd_t);
static int eibnx_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int eibnx_bus_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t,
    void *, void *);

static int eibnx_get_eventcookie(dev_info_t *, dev_info_t *, char *,
    ddi_eventcookie_t *);
static int eibnx_add_eventcall(dev_info_t *, dev_info_t *, ddi_eventcookie_t,
    void (*)(dev_info_t *, ddi_eventcookie_t, void *, void *),
    void *, ddi_callback_id_t *);
static int eibnx_remove_eventcall(dev_info_t *, ddi_callback_id_t);
static int eibnx_post_event(dev_info_t *, dev_info_t *,
    ddi_eventcookie_t, void *);

static int eibnx_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t,
    void *, dev_info_t **);
static int eibnx_bus_unconfig(dev_info_t *, uint_t, ddi_bus_config_op_t,
    void *);
static int eibnx_config_all_children(dev_info_t *);
static void eibnx_unconfig_all_children(dev_info_t *);
static int eibnx_config_child(char *, dev_info_t **);
static int eibnx_unconfig_child(char *);

/*
 * Cbops
 */
static struct cb_ops enx_cb_ops = {
        eibnx_devctl_open,      /* cb_open */
        eibnx_devctl_close,     /* cb_close */
        nodev,                  /* cb_strategy */
        nodev,                  /* cb_print */
        nodev,                  /* cb_dump */
        nodev,                  /* cb_read */
        nodev,                  /* cb_write */
        eibnx_devctl_ioctl,     /* cb_ioctl */
        nodev,                  /* cb_devmap */
        nodev,                  /* cb_mmap */
        nodev,                  /* cb_segmap */
        nochpoll,               /* cb_chpoll */
        ddi_prop_op,            /* cb_prop_op */
        NULL,                   /* cb_str */
        D_MP,                   /* cb_flag */
        CB_REV,                 /* cb_rev */
        nodev,                  /* cb_aread */
        nodev                   /* cb_awrite */
};

/*
 * Busops
 */
static struct bus_ops enx_bus_ops = {
        BUSO_REV,
        nullbusmap,             /* bus_map */
        NULL,                   /* bus_get_intrspec */
        NULL,                   /* bus_add_intrspec */
        NULL,                   /* bus_remove_intrspec */
        i_ddi_map_fault,        /* bus_map_fault */
        ddi_no_dma_map,         /* bus_dma_map */
        NULL,                   /* bus_dma_allochdl */
        NULL,                   /* bus_dma_freehdl */
        NULL,                   /* bus_dma_bindhdl */
        NULL,                   /* bus_dma_unbindhdl */
        NULL,                   /* bus_dma_flush */
        NULL,                   /* bus_dma_win */
        NULL,                   /* bus_dma_ctl */
        eibnx_bus_ctl,          /* bus_ctl */
        ddi_bus_prop_op,        /* bus_prop_op */
        eibnx_get_eventcookie,  /* bus_get_eventcookie */
        eibnx_add_eventcall,    /* bus_add_eventcall */
        eibnx_remove_eventcall, /* bus_remove_eventcall */
        eibnx_post_event,       /* bus_post_event */
        NULL,                   /* bus_intr_ctl */
        eibnx_bus_config,       /* bus_config */
        eibnx_bus_unconfig,     /* bus_unconfig */
};

/*
 * Nexus ops
 */
static struct dev_ops enx_ops = {
        DEVO_REV,               /* devo_rev, */
        0,                      /* devo_refcnt  */
        eibnx_getinfo,          /* devo_info */
        nulldev,                /* devo_identify */
        nulldev,                /* devo_probe */
        eibnx_attach,           /* devo_attach */
        eibnx_detach,           /* devo_detach */
        nodev,                  /* devo_reset */
        &enx_cb_ops,            /* devo_cb_ops */
        &enx_bus_ops,           /* devo_bus_ops */
        nulldev,                /* devo_power */
        ddi_quiesce_not_needed  /* devo_quiesce */
};

/*
 * Module linkage information for the kernel
 */
static struct modldrv enx_modldrv = {
        &mod_driverops,         /* Driver module */
        "EoIB Nexus",           /* Driver name and version */
        &enx_ops,               /* Driver ops */
};

static struct modlinkage enx_modlinkage = {
        MODREV_1, (void *)&enx_modldrv, NULL
};

/*
 * EoIB NDI events
 */
static ndi_event_definition_t enx_ndi_event_defs[] = {
        { ENX_EVENT_TAG_GW_INFO_UPDATE, EIB_NDI_EVENT_GW_INFO_UPDATE,
                EPL_KERNEL, NDI_EVENT_POST_TO_TGT },
        { ENX_EVENT_TAG_GW_AVAILABLE, EIB_NDI_EVENT_GW_AVAILABLE,
                EPL_KERNEL, NDI_EVENT_POST_TO_TGT },
        { ENX_EVENT_TAG_LOGIN_ACK, EIB_NDI_EVENT_LOGIN_ACK,
                EPL_KERNEL, NDI_EVENT_POST_TO_TGT }
};
#define ENX_NUM_NDI_EVENTS              \
        (sizeof (enx_ndi_event_defs) / sizeof (enx_ndi_event_defs[0]))

static ndi_event_set_t enx_ndi_events = {
        NDI_EVENTS_REV1,
        ENX_NUM_NDI_EVENTS,
        enx_ndi_event_defs
};
ndi_event_hdl_t enx_ndi_event_hdl;


/*
 * Common loadable module entry points _init, _fini, _info
 */

int
_init(void)
{
        int ret;

        if ((ret = mod_install(&enx_modlinkage)) == 0)
                eibnx_debug_init();

        return (ret);
}

int
_fini(void)
{
        int ret;

        if ((ret = mod_remove(&enx_modlinkage)) == 0)
                eibnx_debug_fini();

        return (ret);
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&enx_modlinkage, modinfop));
}

/*
 * Autoconfiguration entry points: attach, detach, getinfo
 */

static int
eibnx_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        eibnx_t *ss;
        int instance;

        if (cmd == DDI_RESUME)
                return (DDI_SUCCESS);
        else if (cmd != DDI_ATTACH)
                return (DDI_FAILURE);

        /*
         * Don't allow more than one instance to attach
         */
        if (enx_global_ss)
                return (DDI_FAILURE);

        /*
         * Alloc this instance's softstate
         */
        ss = kmem_zalloc(sizeof (eibnx_t), KM_SLEEP);
        ss->nx_dip = dip;

        enx_global_ss = ss;

        /*
         * Allocate our NDI event handle and bind our event set
         */
        if (ndi_event_alloc_hdl(dip, 0, &enx_ndi_event_hdl,
            NDI_SLEEP) != NDI_SUCCESS) {
                ENX_DPRINTF_ERR("ndi_event_alloc_hdl(dip=0x%llx) "
                    "failed", dip);

                kmem_free(enx_global_ss, sizeof (eibnx_t));
                enx_global_ss = NULL;
                return (DDI_FAILURE);
        }
        if (ndi_event_bind_set(enx_ndi_event_hdl, &enx_ndi_events,
            NDI_SLEEP) != NDI_SUCCESS) {
                ENX_DPRINTF_ERR("ndi_event_bind_set(ndi_event_hdl=0x%llx) "
                    "failed", enx_ndi_event_hdl);

                (void) ndi_event_free_hdl(enx_ndi_event_hdl);
                enx_ndi_event_hdl = NULL;
                kmem_free(enx_global_ss, sizeof (eibnx_t));
                enx_global_ss = NULL;
                return (DDI_FAILURE);
        }

        /*
         * Create "devctl" minor node for general ioctl interface to the
         * eoib nexus. If we cannot, it isn't fatal - we'll operate without
         * the support for devctl (but issue a warning).
         */
        instance = ddi_get_instance(dip);
        if (ddi_create_minor_node(dip, "devctl", S_IFCHR, instance,
            DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
                ENX_DPRINTF_WARN("could not create devctl minor node "
                    "for instance %d", instance);
        }

        /*
         * Do IBTF related initializations. If we fail, we cannot operate,
         * so fail the attach.
         */
        if (eibnx_ibt_init(ss) != ENX_E_SUCCESS) {
                (void) ddi_remove_minor_node(dip, NULL);
                (void) ndi_event_unbind_set(enx_ndi_event_hdl,
                    &enx_ndi_events, NDI_SLEEP);
                (void) ndi_event_free_hdl(enx_ndi_event_hdl);
                enx_ndi_event_hdl = NULL;
                kmem_free(enx_global_ss, sizeof (eibnx_t));
                enx_global_ss = NULL;
                return (DDI_FAILURE);
        }

        return (DDI_SUCCESS);
}

static int
eibnx_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        eibnx_t *ss = enx_global_ss;

        if (cmd == DDI_SUSPEND)
                return (DDI_SUCCESS);
        else if (cmd != DDI_DETACH)
                return (DDI_FAILURE);

        /*
         * If there's no instance of eibnx attached, fail
         */
        if (ss == NULL)
                return (DDI_FAILURE);

        /*
         * Before we do anything, we need to stop the port monitors
         * we may have started earlier.
         */
        eibnx_terminate_monitors();

        /*
         * If eibnx_ibt_fini() fails, it could be because one of the
         * HCA's pd could not be freed, the hca could not be closed
         * or the IBTF detach wasn't successful.  If this is the case,
         * we have to return failure, but cannot do much about the
         * port monitors we've already terminated.
         */
        if (eibnx_ibt_fini(ss) == ENX_E_FAILURE)
                return (DDI_FAILURE);

        /*
         * Cleanup any devctl minor node we may have created, unbind and
         * free ndi event handle and free the instance softstate.
         */
        (void) ddi_remove_minor_node(dip, NULL);
        (void) ndi_event_unbind_set(enx_ndi_event_hdl,
            &enx_ndi_events, NDI_SLEEP);
        (void) ndi_event_free_hdl(enx_ndi_event_hdl);
        enx_ndi_event_hdl = NULL;
        kmem_free(enx_global_ss, sizeof (eibnx_t));
        enx_global_ss = NULL;

        return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
eibnx_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
        eibnx_t *ss = enx_global_ss;
        int ret;

        if (cmd == DDI_INFO_DEVT2DEVINFO) {
                *resultp = (ss) ? ss->nx_dip : NULL;
                ret = (ss) ? DDI_SUCCESS : DDI_FAILURE;
        } else if (cmd == DDI_INFO_DEVT2INSTANCE) {
                *resultp = 0;
                ret = DDI_SUCCESS;
        } else {
                ret = DDI_FAILURE;
        }

        return (ret);
}

/*
 * Busops: bus_ctl, bus_config, bus_unconfig
 */

/*ARGSUSED*/
static int
eibnx_bus_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
    void *arg, void *result)
{
        dev_info_t *child = arg;
        int ret;
        char name[MAXNAMELEN];

        switch (ctlop) {
        case DDI_CTLOPS_REPORTDEV:
                ENX_DPRINTF_DEBUG("EoIB device: %s@%s, %s%d",
                    ddi_node_name(rdip), ddi_get_name_addr(rdip),
                    ddi_driver_name(rdip), ddi_get_instance(rdip));
                /*FALLTHROUGH*/

        case DDI_CTLOPS_ATTACH:
        case DDI_CTLOPS_DETACH:
        case DDI_CTLOPS_POWER:
        case DDI_CTLOPS_SIDDEV:
        case DDI_CTLOPS_IOMIN:
                ret = DDI_SUCCESS;
                break;

        case DDI_CTLOPS_INITCHILD:
                if ((ret = eibnx_name_child(child, name,
                    sizeof (name))) == DDI_SUCCESS) {
                        ddi_set_name_addr(child, name);
                }
                break;

        case DDI_CTLOPS_UNINITCHILD:
                ddi_set_name_addr(child, NULL);
                ret = DDI_SUCCESS;
                break;

        default:
                ret = ddi_ctlops(dip, rdip, ctlop, arg, result);
                break;
        }

        return (ret);
}

/*ARGSUSED*/
static int
eibnx_bus_config(dev_info_t *parent, uint_t flags,
    ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
{
        eibnx_t *ss = enx_global_ss;
        int ret = NDI_SUCCESS;

        switch (op) {
        case BUS_CONFIG_ONE:
                eibnx_busop_inprog_enter(ss);
                ret = eibnx_config_child(arg, childp);
                eibnx_busop_inprog_exit(ss);
                break;

        case BUS_CONFIG_ALL:
        case BUS_CONFIG_DRIVER:
                eibnx_busop_inprog_enter(ss);
                if ((ss->nx_busop_flags & NX_FL_BUSCFG_COMPLETE) == 0) {
                        ret = eibnx_config_all_children(parent);
                        if (ret == NDI_SUCCESS)
                                ss->nx_busop_flags |= NX_FL_BUSCFG_COMPLETE;
                }
                eibnx_busop_inprog_exit(ss);
                break;

        default:
                ret = NDI_FAILURE;
        }

        if (ret == NDI_SUCCESS)
                ret = ndi_busop_bus_config(parent, flags, op, arg, childp, 0);

        return (ret);
}

static int
eibnx_bus_unconfig(dev_info_t *parent, uint_t flags,
    ddi_bus_config_op_t op, void *arg)
{
        eibnx_t *ss = enx_global_ss;
        int ret;

        ret = ndi_busop_bus_unconfig(parent, flags, op, arg);
        if (ret != NDI_SUCCESS)
                return (ret);

        switch (op) {
        case BUS_UNCONFIG_ONE:
                if (flags & (NDI_UNCONFIG | NDI_DEVI_REMOVE)) {
                        eibnx_busop_inprog_enter(ss);

                        if ((ret = eibnx_unconfig_child(arg)) == ENX_E_SUCCESS)
                                ss->nx_busop_flags &= (~NX_FL_BUSCFG_COMPLETE);
                        else {
                                ENX_DPRINTF_DEBUG("eibnx_bus_config: "
                                    "unconfig child %s failed", (char *)arg);
                        }

                        eibnx_busop_inprog_exit(ss);
                }
                break;

        case BUS_UNCONFIG_ALL:
        case BUS_UNCONFIG_DRIVER:
                if (flags & (NDI_UNCONFIG | NDI_DEVI_REMOVE)) {
                        eibnx_busop_inprog_enter(ss);

                        eibnx_unconfig_all_children(parent);
                        ss->nx_busop_flags &= (~NX_FL_BUSCFG_COMPLETE);

                        eibnx_busop_inprog_exit(ss);
                }
                break;

        default:
                break;
        }

        return (ret);
}

/*
 * Event Handling: bus_get_eventcookie, bus_add_eventcall, bus_remove_eventcall
 * and bus_post_event
 */

/*ARGSUSED*/
static int
eibnx_get_eventcookie(dev_info_t *dip, dev_info_t *rdip,
    char *name, ddi_eventcookie_t *cookiep)
{
        return (ndi_event_retrieve_cookie(enx_ndi_event_hdl, rdip, name,
            cookiep, NDI_EVENT_NOPASS));
}

/*ARGSUSED*/
static int
eibnx_add_eventcall(dev_info_t *dip, dev_info_t *rdip, ddi_eventcookie_t cookie,
    void (*callback)(dev_info_t *cb_dip, ddi_eventcookie_t cb_cookie,
    void *cb_arg, void *cb_impl_data),
    void *arg, ddi_callback_id_t *cb_id)
{
        return (ndi_event_add_callback(enx_ndi_event_hdl, rdip, cookie,
            callback, arg, NDI_SLEEP, cb_id));
}

/*ARGSUSED*/
static int
eibnx_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
{
        return (ndi_event_remove_callback(enx_ndi_event_hdl, cb_id));
}

/*ARGSUSED*/
static int
eibnx_post_event(dev_info_t *dip, dev_info_t *rdip,
    ddi_eventcookie_t cookie, void *impl_data)
{
        return (ndi_event_run_callbacks(enx_ndi_event_hdl, rdip, cookie,
            impl_data));
}

/*
 * Routines to configure/unconfigure EoIB node(s) on a system.
 */

/*ARGSUSED*/
static int
eibnx_config_all_children(dev_info_t *parent)
{
        eibnx_t *ss = enx_global_ss;
        eibnx_hca_t *hca;
        eibnx_port_t *port;
        eibnx_thr_info_t *ti;
        eibnx_thr_info_t *ti_tail;
        eibnx_gw_info_t *gwi;

        /*
         * Go through each port of each hca and create a thread to solicit,
         * monitor, receive advertisements, create eoib nodes and attach eoib
         * driver instances.
         */
        mutex_enter(&ss->nx_lock);
        if (!ss->nx_monitors_up) {
                ss->nx_thr_info = ti_tail = NULL;
                for (hca = ss->nx_hca; hca; hca = hca->hc_next) {
                        for (port = hca->hc_port; port; port = port->po_next) {
                                ti = eibnx_start_port_monitor(hca, port);
                                if (ti_tail) {
                                        ti_tail->ti_next = ti;
                                } else {
                                        ss->nx_thr_info = ti;
                                }
                                ti_tail = ti;
                        }
                }

                ss->nx_monitors_up = B_TRUE;
                mutex_exit(&ss->nx_lock);

                return (NDI_SUCCESS);
        }
        mutex_exit(&ss->nx_lock);

        while (eibnx_locate_unconfigured_node(&ti, &gwi) == ENX_E_SUCCESS)
                (void) eibnx_configure_node(ti, gwi, NULL);

        return (NDI_SUCCESS);
}

/*
 * Routine to unconfigure all the EoIB nodes on a system. This terminates
 * all the per-port monitor threads and releases any resources allocated.
 */

/*ARGSUSED*/
static void
eibnx_unconfig_all_children(dev_info_t *parent)
{
        eibnx_t *ss = enx_global_ss;
        eibnx_thr_info_t *ti;
        eibnx_child_t *ch;

        mutex_enter(&ss->nx_lock);
        for (ti = ss->nx_thr_info; ti; ti = ti->ti_next) {
                mutex_enter(&ti->ti_child_lock);
                for (ch = ti->ti_child; ch; ch = ch->ch_next) {
                        ch->ch_dip = NULL;
                }
                mutex_exit(&ti->ti_child_lock);
        }
        mutex_exit(&ss->nx_lock);
}

/*ARGSUSED*/
static int
eibnx_config_child(char *devname, dev_info_t **childp)
{
        eibnx_thr_info_t *ti;
        eibnx_gw_info_t *gwi;

        if (eibnx_locate_node_name(devname, &ti, &gwi) == ENX_E_FAILURE) {
                ENX_DPRINTF_DEBUG("eibnx_config_child: invalid eoib "
                    "nodename %s, no such address", devname);
                return (ENX_E_FAILURE);
        }

        return (eibnx_configure_node(ti, gwi, childp));
}

/*ARGSUSED*/
static int
eibnx_unconfig_child(char *devname)
{
        eibnx_thr_info_t *ti;
        eibnx_gw_info_t *gwi;

        if (eibnx_locate_node_name(devname, &ti, &gwi) == ENX_E_FAILURE) {
                ENX_DPRINTF_DEBUG("eibnx_unconfig_child: invalid eoib "
                    "nodename %s, no such address", devname);
                return (ENX_E_FAILURE);
        }

        return (eibnx_unconfigure_node(ti, gwi));
}