/*
 * 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 <sys/types.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/promif_impl.h>
#include <sys/ds.h>
#include <sys/modctl.h>
#include <sys/ksynch.h>
#include <sys/varconfig.h>

#ifndef _KMDB

#define PROMIF_DS_TIMEOUT_SEC 15

static kmutex_t promif_prop_lock;
static kcondvar_t promif_prop_cv;
static var_config_msg_t promif_ds_resp;
static var_config_resp_t *cfg_rsp = &promif_ds_resp.var_config_resp;
static int (*ds_send)();
static int (*ds_init)();

/*
 * Domains Services interaction
 */
static ds_svc_hdl_t     ds_primary_handle;
static ds_svc_hdl_t     ds_backup_handle;

static ds_ver_t         vc_version[] = { { 1, 0 } };

#define VC_NVERS        (sizeof (vc_version) / sizeof (vc_version[0]))

static ds_capability_t vc_primary_cap = {
        "var-config",           /* svc_id */
        vc_version,             /* vers */
        VC_NVERS                /* nvers */
};

static ds_capability_t vc_backup_cap = {
        "var-config-backup",    /* svc_id */
        vc_version,             /* vers */
        VC_NVERS                /* nvers */
};

static void vc_reg_handler(ds_cb_arg_t, ds_ver_t *, ds_svc_hdl_t);
static void vc_unreg_handler(ds_cb_arg_t);
static void vc_data_handler(ds_cb_arg_t, void *, size_t);

static ds_clnt_ops_t vc_primary_ops = {
        vc_reg_handler,         /* ds_primary_reg_cb */
        vc_unreg_handler,       /* ds_primary_unreg_cb */
        vc_data_handler,        /* ds_data_cb */
        &ds_primary_handle      /* cb_arg */
};

static ds_clnt_ops_t vc_backup_ops = {
        vc_reg_handler,         /* ds_backup_reg_cb */
        vc_unreg_handler,       /* ds_backup_unreg_cb */
        vc_data_handler,        /* ds_data_cb */
        &ds_backup_handle       /* cb_arg */
};

static void
vc_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl)
{
        _NOTE(ARGUNUSED(ver))

        if ((ds_svc_hdl_t *)arg == &ds_primary_handle)
                ds_primary_handle = hdl;
        else if ((ds_svc_hdl_t *)arg == &ds_backup_handle)
                ds_backup_handle = hdl;
}

static void
vc_unreg_handler(ds_cb_arg_t arg)
{
        if ((ds_svc_hdl_t *)arg == &ds_primary_handle)
                ds_primary_handle = DS_INVALID_HDL;
        else if ((ds_svc_hdl_t *)arg == &ds_backup_handle)
                ds_backup_handle = DS_INVALID_HDL;
}

static void
vc_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
        _NOTE(ARGUNUSED(arg))

        bcopy(buf, &promif_ds_resp, buflen);
        mutex_enter(&promif_prop_lock);
        cv_signal(&promif_prop_cv);
        mutex_exit(&promif_prop_lock);
}

/*
 * Initialize the linkage with DS (Domain Services).  We assume that
 * the DS module has already been loaded by the platmod.
 *
 * The call to the DS init functions will eventually result in the
 * invocation of our registration callback handlers, at which time DS
 * is able to accept requests.
 */
static void
promif_ds_init(void)
{
        static char *me = "promif_ds_init";
        int rv;

        if ((ds_init =
            (int (*)())modgetsymvalue("ds_cap_init", 0)) == 0) {
                cmn_err(CE_WARN, "%s: can't find ds_cap_init", me);
                return;
        }

        if ((ds_send =
            (int (*)())modgetsymvalue("ds_cap_send", 0)) == 0) {
                cmn_err(CE_WARN, "%s: can't find ds_cap_send", me);
                return;
        }

        if ((rv = (*ds_init)(&vc_primary_cap, &vc_primary_ops)) != 0) {
                cmn_err(CE_NOTE,
                    "%s: ds_cap_init failed (primary): %d", me, rv);
        }


        if ((rv = (*ds_init)(&vc_backup_cap, &vc_backup_ops)) != 0) {
                cmn_err(CE_NOTE,
                    "%s: ds_cap_init failed (backup): %d", me, rv);
        }
}

/*
 * Prepare for ldom variable requests.
 */
void
promif_prop_init(void)
{
        mutex_init(&promif_prop_lock, NULL, MUTEX_DEFAULT, NULL);
        cv_init(&promif_prop_cv, NULL, CV_DEFAULT, NULL);

        promif_ds_init();
}


/*
 * Replace the current value of a property string given its name and
 * new value.
 */
int
promif_ldom_setprop(char *name, void *value, int valuelen)
{
        var_config_msg_t *req;
        var_config_set_req_t *setp;
        var_config_cmd_t cmd;
        ds_svc_hdl_t ds_handle;
        int rv;
        int namelen = strlen(name);
        int paylen = namelen + 1 + valuelen; /* valuelen includes the null */
        static char *me = "promif_ldom_setprop";

        if (ds_primary_handle != DS_INVALID_HDL)
                ds_handle = ds_primary_handle;
        else if (ds_backup_handle != DS_INVALID_HDL)
                ds_handle = ds_backup_handle;
        else
                return (-1);

        /*
         * Since we are emulating OBP, we must comply with the promif
         * infrastructure and execute only on the originating cpu.
         */
        thread_affinity_set(curthread, CPU->cpu_id);

        req = kmem_zalloc(sizeof (var_config_hdr_t) + paylen, KM_SLEEP);
        req->var_config_cmd = VAR_CONFIG_SET_REQ;
        setp = &req->var_config_set;
        (void) strcpy(setp->name_and_value, name);
        (void) strncpy(&setp->name_and_value[namelen + 1], value, valuelen);

        if ((rv = (*ds_send)(ds_handle, req,
            sizeof (var_config_hdr_t) + paylen)) != 0) {
                cmn_err(CE_WARN, "%s: ds_cap_send failed: %d", me, rv);
                kmem_free(req, sizeof (var_config_hdr_t) + paylen);
                thread_affinity_clear(curthread);
                return (-1);
        }

        kmem_free(req, sizeof (var_config_hdr_t) + paylen);

        mutex_enter(&promif_prop_lock);
        if (cv_reltimedwait(&promif_prop_cv, &promif_prop_lock,
            PROMIF_DS_TIMEOUT_SEC * hz, TR_CLOCK_TICK) == -1) {
                cmn_err(CE_WARN, "%s: ds response timeout", me);
                rv = -1;
                goto out;
        }

        cmd = promif_ds_resp.vc_hdr.cmd;
        if (cmd != VAR_CONFIG_SET_RESP) {
                cmn_err(CE_WARN, "%s: bad response type: %d", me, cmd);
                rv = -1;
                goto out;
        }
        rv = (cfg_rsp->result == VAR_CONFIG_SUCCESS) ? valuelen : -1;

out:
        mutex_exit(&promif_prop_lock);
        thread_affinity_clear(curthread);
        return (rv);
}

int
promif_setprop(void *p)
{
        cell_t  *ci = (cell_t *)p;
        pnode_t node;
        caddr_t name;
        caddr_t value;
        int     len;

        ASSERT(ci[1] == 4);

        node  = p1275_cell2dnode(ci[3]);
        ASSERT(node == prom_optionsnode());
        name  = p1275_cell2ptr(ci[4]);
        value = p1275_cell2ptr(ci[5]);
        len = p1275_cell2int(ci[6]);

        if (promif_stree_getproplen(node, name) != -1)
                len = promif_ldom_setprop(name, value, len);

        if (len >= 0)
                len = promif_stree_setprop(node, name, (void *)value, len);


        ci[7] = p1275_int2cell(len);

        return ((len == -1) ? len : 0);
}

#endif

int
promif_getprop(void *p)
{
        cell_t  *ci = (cell_t *)p;
        pnode_t node;
        caddr_t name;
        caddr_t value;
        int     len;

        ASSERT(ci[1] == 4);

        node  = p1275_cell2dnode(ci[3]);
        name  = p1275_cell2ptr(ci[4]);
        value = p1275_cell2ptr(ci[5]);

        len = promif_stree_getprop(node, name, value);

        ci[7] = p1275_int2cell(len);

        return ((len == -1) ? len : 0);
}

int
promif_getproplen(void *p)
{
        cell_t  *ci = (cell_t *)p;
        pnode_t node;
        caddr_t name;
        int     len;

        ASSERT(ci[1] == 2);

        node = p1275_cell2dnode(ci[3]);
        name = p1275_cell2ptr(ci[4]);

        len = promif_stree_getproplen(node, name);

        ci[5] = p1275_int2cell(len);

        return (0);
}

int
promif_nextprop(void *p)
{
        cell_t  *ci = (cell_t *)p;
        pnode_t node;
        caddr_t prev;
        caddr_t next;

        ASSERT(ci[1] == 3);

        node = p1275_cell2dnode(ci[3]);
        prev = p1275_cell2ptr(ci[4]);
        next = p1275_cell2ptr(ci[5]);

        (void) promif_stree_nextprop(node, prev, next);

        return (0);
}