/*
 * 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/types.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/strsubr.h>
#include <sys/socketvar.h>
#include <sys/rds.h>

#include <sys/ib/ibtl/ibti.h>
#include <sys/ib/clients/rdsv3/rdsv3.h>
#include <sys/ib/clients/rdsv3/rdsv3_debug.h>
#include <sys/ib/clients/rdsv3/rdsv3_af_thr.h>

extern int rdsv3_init(void);
extern void rdsv3_exit(void);
extern void rdsv3_cong_init(void);
extern void rdsv3_cong_exit(void);
extern void rdsv3_trans_init(void);
extern void rdsv3_trans_exit(void);
extern int rdsv3_sock_init(void);
extern void rdsv3_sock_exit(void);

/* global */
dev_info_t      *rdsv3_dev_info = NULL;
kmem_cache_t    *rdsv3_alloc_cache = NULL;

extern kmutex_t rdsv3_rdma_listen_id_lock;
extern struct rdma_cm_id *rdsv3_rdma_listen_id;

extern kmutex_t rdsv3_sock_lock;
extern list_t rdsv3_sock_list;

extern void rdsv3_bind_init();
extern void rdsv3_bind_exit();

int
rdsv3_sock_init()
{
        RDSV3_DPRINTF4("rdsv3_sock_init", "Enter");

        rdsv3_alloc_cache = kmem_cache_create("rdsv3_alloc_cache",
            sizeof (struct rsock) + sizeof (struct rdsv3_sock), 0, NULL,
            NULL, NULL, NULL, NULL, 0);
        if (rdsv3_alloc_cache == NULL) {
                RDSV3_DPRINTF2("rdsv3_alloc_cache",
                    "kmem_cache_create(rdsv3_alloc_cache) failed");
                return (-1);
        }
        rdsv3_bind_init();

        mutex_init(&rdsv3_sock_lock, NULL, MUTEX_DRIVER, NULL);
        list_create(&rdsv3_sock_list, sizeof (struct rdsv3_sock),
            offsetof(struct rdsv3_sock, rs_item));

        RDSV3_DPRINTF4("rdsv3_sock_init", "Return");

        return (0);
}

void
rdsv3_sock_exit()
{
        RDSV3_DPRINTF2("rdsv3_sock_exit", "Enter");

        rdsv3_bind_exit();

        kmem_cache_destroy(rdsv3_alloc_cache);

        list_destroy(&rdsv3_sock_list);
        mutex_destroy(&rdsv3_sock_lock);

        RDSV3_DPRINTF2("rdsv3_sock_exit", "Return");
}

static int
rdsv3_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int     ret;

        RDSV3_DPRINTF2("rdsv3_attach", "Enter (dip: %p)", dip);

        if (cmd != DDI_ATTACH)
                return (DDI_FAILURE);

        if (rdsv3_dev_info != NULL) {
                RDSV3_DPRINTF2("rdsv3_attach", "Multiple RDS instances are"
                    " not supported (rdsv3_dev_info: 0x%p)", rdsv3_dev_info);
                return (DDI_FAILURE);
        }
        rdsv3_dev_info = dip;

        mutex_init(&rdsv3_rdma_listen_id_lock, NULL, MUTEX_DRIVER, NULL);
        rdsv3_rdma_listen_id = NULL;

        rdsv3_af_init(dip);
        rdsv3_trans_init();
        ret = rdsv3_init();
        if (ret) {
                RDSV3_DPRINTF2("rdsv3_attach", "rdsv3_init failed: %d", ret);
                rdsv3_trans_exit();
                mutex_destroy(&rdsv3_rdma_listen_id_lock);
                rdsv3_dev_info = NULL;
                return (DDI_FAILURE);
        }

        ret = rdsv3_sock_init();
        if (ret) {
                rdsv3_exit();
                rdsv3_trans_exit();
                mutex_destroy(&rdsv3_rdma_listen_id_lock);
                rdsv3_dev_info = NULL;
                return (DDI_FAILURE);
        }

        ret = ddi_create_minor_node(dip, "rdsv3", S_IFCHR, 0, DDI_PSEUDO, 0);
        if (ret != DDI_SUCCESS) {
                cmn_err(CE_CONT, "ddi_create_minor_node failed: %d", ret);
                rdsv3_sock_exit();
                rdsv3_exit();
                rdsv3_trans_exit();
                mutex_destroy(&rdsv3_rdma_listen_id_lock);
                rdsv3_dev_info = NULL;
                return (DDI_FAILURE);
        }

        RDSV3_DPRINTF2("rdsv3_attach", "Return");

        return (DDI_SUCCESS);
}

static int
rdsv3_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        RDSV3_DPRINTF2("rdsv3_detach", "Enter (dip: %p)", dip);

        if (cmd != DDI_DETACH)
                return (DDI_FAILURE);

        rdsv3_sock_exit();
        rdsv3_exit();
        rdsv3_trans_exit();
        ddi_remove_minor_node(dip, "rdsv3");
        rdsv3_dev_info = NULL;

        RDSV3_DPRINTF2("rdsv3_detach", "Return");

        return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
rdsv3_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
        int ret = DDI_FAILURE;

        RDSV3_DPRINTF2("rdsv3_info", "Enter (dip: %p, cmd: %d)", dip, cmd);

        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                if (rdsv3_dev_info != NULL) {
                        *result = (void *)rdsv3_dev_info;
                        ret = DDI_SUCCESS;
                }
                break;

        case DDI_INFO_DEVT2INSTANCE:
                *result = NULL;
                ret = DDI_SUCCESS;
                break;

        default:
                break;
        }

        RDSV3_DPRINTF4("rdsv3_info", "Return");

        return (ret);
}

/* Driver entry points */
static struct cb_ops    rdsv3_cb_ops = {
        nulldev,                /* open */
        nulldev,                /* close */
        nodev,                  /* strategy */
        nodev,                  /* print */
        nodev,                  /* dump */
        nodev,                  /* read */
        nodev,                  /* write */
        nodev,                  /* ioctl */
        nodev,                  /* devmap */
        nodev,                  /* mmap */
        nodev,                  /* segmap */
        nochpoll,               /* poll */
        ddi_prop_op,            /* prop_op */
        NULL,                   /* stream */
        D_MP,                   /* cb_flag */
        CB_REV,                 /* rev */
        nodev,                  /* int (*cb_aread)() */
        nodev,                  /* int (*cb_awrite)() */
};

/* Device options */
static struct dev_ops rdsv3_ops = {
        DEVO_REV,               /* devo_rev, */
        0,                      /* refcnt  */
        rdsv3_info,             /* info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        rdsv3_attach,           /* attach */
        rdsv3_detach,           /* detach */
        nodev,                  /* reset */
        &rdsv3_cb_ops,          /* driver ops - devctl interfaces */
        NULL,                   /* bus operations */
        NULL,                   /* power */
        ddi_quiesce_not_needed  /* quiesce */
};

/*
 * Module linkage information.
 */
#define RDSV3_DEVDESC   "RDSv3 IB transport driver"
static struct modldrv rdsv3_modldrv = {
        &mod_driverops,         /* Driver module */
        RDSV3_DEVDESC,          /* Driver name and version */
        &rdsv3_ops,             /* Driver ops */
};

static struct modlinkage rdsv3_modlinkage = {
        MODREV_1,
        (void *)&rdsv3_modldrv,
        NULL
};

int
_init(void)
{
        int     ret;

        if (ibt_hw_is_present() == 0) {
                return (ENODEV);
        }

        /* Initialize logging */
        rdsv3_logging_initialization();

        ret = mod_install(&rdsv3_modlinkage);
        if (ret != 0) {
                /*
                 * Could not load module
                 */
                rdsv3_logging_destroy();
                return (ret);
        }

        return (0);
}

int
_fini()
{
        int     ret;

        /*
         * Remove module
         */
        if ((ret = mod_remove(&rdsv3_modlinkage)) != 0) {
                return (ret);
        }

        /* Stop logging */
        rdsv3_logging_destroy();

        return (0);
}

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