/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * Kernel framework functions for the fcode interpreter
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/debug.h>
#include <sys/kmem.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/esunddi.h>
#include <sys/ksynch.h>
#include <sys/modctl.h>
#include <sys/errno.h>
#include <sys/fcode.h>

#ifdef  DEBUG
int fcode_debug = 0;
#else
int fcode_debug = 0;
#endif

static kmutex_t fc_request_lock;
static kmutex_t fc_resource_lock;
static kmutex_t fc_hash_lock;
static kmutex_t fc_device_tree_lock;
static kmutex_t fc_phandle_lock;
static kcondvar_t fc_request_cv;
static struct fc_request *fc_request_head;
static int fc_initialized;

static void fcode_timer(void *);

int fcode_timeout = 300;        /* seconds */

int fcodem_unloadable;

extern int hz;

/*
 * Initialize the fcode interpreter framework ... must be called
 * prior to activating any of the fcode interpreter framework including
 * the driver.
 */
static void
fcode_init(void)
{
        if (fc_initialized)
                return;

        mutex_init(&fc_request_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&fc_resource_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&fc_hash_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&fc_device_tree_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&fc_phandle_lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&fc_request_cv, NULL, CV_DRIVER, NULL);
        ++fc_initialized;
}

static void
fcode_fini(void)
{
        mutex_destroy(&fc_request_lock);
        mutex_destroy(&fc_resource_lock);
        mutex_destroy(&fc_hash_lock);
        cv_destroy(&fc_request_cv);
        fc_initialized = 0;
}

/*
 * Module linkage information for the kernel.
 */
static struct modlmisc modlmisc = {
        &mod_miscops, "FCode framework 1.13"
};

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

int
_init(void)
{
        int error;

        fcode_init();
        if ((error = mod_install(&modlinkage)) != 0)
                fcode_fini();
        return (error);
}

int
_fini(void)
{
        int error = EBUSY;

        if (fcodem_unloadable)
                if ((error = mod_remove(&modlinkage)) == 0)
                        fcode_fini();

        return (error);
}

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

/*
 * Framework function to invoke the interpreter. Wait and return when the
 * interpreter is done. See fcode.h for details.
 */
int
fcode_interpreter(dev_info_t *ap, fc_ops_t *ops, fco_handle_t handle)
{
        struct fc_request *fp, *qp;
        int error;

        ASSERT(fc_initialized);
        ASSERT(ap);
        ASSERT(ops);
        ASSERT(handle);

        /*
         * Create a request structure
         */
        fp = kmem_zalloc(sizeof (struct fc_request), KM_SLEEP);

        fp->next = NULL;
        fp->busy = FC_R_INIT;
        fp->error = FC_SUCCESS;
        fp->ap_dip = ap;
        fp->ap_ops = ops;
        fp->handle = handle;

        /*
         * Add the request to the end of the request list.
         */
        mutex_enter(&fc_request_lock);

        if (fc_request_head == NULL)
                fc_request_head = fp;
        else {
                for (qp = fc_request_head; qp->next != NULL; qp = qp->next)
                        /* empty */;
                qp->next = fp;
        }
        mutex_exit(&fc_request_lock);

        /*
         * log a message (ie: i_ddi_log_event) indicating that a request
         * has been queued to start the userland fcode interpreter.
         * This call is the glue to the eventd and automates the process.
         */

        /*
         * Signal the driver if it's waiting for a request to be queued.
         */
        cv_broadcast(&fc_request_cv);

        /*
         * Wait for the request to be serviced
         */
        mutex_enter(&fc_request_lock);
        fp->timeout = timeout(fcode_timer, fp, hz * fcode_timeout);
        while (fp->busy != FC_R_DONE)
                cv_wait(&fc_request_cv, &fc_request_lock);

        if (fp->timeout) {
                (void) untimeout(fp->timeout);
                fp->timeout = NULL;
        }

        /*
         * Remove the request from the queue (while still holding the lock)
         */
        if (fc_request_head == fp)
                fc_request_head = fp->next;
        else {
                for (qp = fc_request_head; qp->next != fp; qp = qp->next)
                        /* empty */;
                qp->next = fp->next;
        }
        mutex_exit(&fc_request_lock);

        FC_DEBUG1(2, CE_CONT, "fcode_interpreter: request finished, fp %p\n",
            fp);

        /*
         * Free the request structure and return any errors.
         */
        error = fp->error;
        kmem_free(fp, sizeof (struct fc_request));
        return (error);
}

/*
 * Timeout requests thet don't get picked up by the interpreter.  This
 * would happen if the daemon is not running.  If the timer goes off
 * and it's state is not FC_R_INIT, then the interpreter has picked up the
 * request.
 */
static void
fcode_timer(void *arg)
{
        struct fc_request *fp = arg;

        mutex_enter(&fc_request_lock);
        fp->timeout = 0;
        if (fp->busy == FC_R_INIT) {
                cmn_err(CE_WARN, "fcode_timer: Timeout waiting for "
                    "interpreter - Interpreter did not pick up request\n");
                fp->busy = FC_R_DONE;
                fp->error = FC_TIMEOUT;
                mutex_exit(&fc_request_lock);
                cv_broadcast(&fc_request_cv);
                return;
        } else if (fp->error != FC_SUCCESS) {
                /*
                 * An error was detected, but didn't close the driver.
                 * This will allow the process to error out, returning
                 * the interpreter error code instead of FC_TIMEOUT.
                 */
                fp->busy = FC_R_DONE;
                cv_broadcast(&fc_request_cv);
                mutex_exit(&fc_request_lock);
                return;
        } else {
                cmn_err(CE_WARN, "fcode_timer: Timeout waiting for "
                    "interpreter - Interpreter is executing request\n");
        }
        mutex_exit(&fc_request_lock);
}

/*
 * This is the function the driver calls to wait for and get
 * a request.  The call should be interruptable since it's done
 * at read(2) time, so allow for signals to interrupt us.
 *
 * Return NULL if the wait was interrupted, else return a pointer
 * to the fc_request structure (marked as busy).
 *
 * Note that we have to check for a request first, before waiting,
 * in case the request is already queued. In this case, the signal
 * may have already been delivered.
 */
struct fc_request *
fc_get_request(void)
{
        struct fc_request *fp;

        ASSERT(fc_initialized);

        mutex_enter(&fc_request_lock);

        /*CONSTANTCONDITION*/
        while (1) {
                for (fp = fc_request_head; fp != NULL; fp = fp->next) {
                        if (fp->busy == FC_R_INIT) {
                                fp->busy = FC_R_BUSY;
                                mutex_exit(&fc_request_lock);
                                return (fp);
                        }
                }
                if (cv_wait_sig(&fc_request_cv, &fc_request_lock) == 0) {
                        mutex_exit(&fc_request_lock);
                        return (NULL);
                }
        }
        /*NOTREACHED*/
}

/*
 * This is the function the driver calls when it's finished with
 * a request.  Mark the request as done and signal the thread that
 * enqueued the request.
 */
void
fc_finish_request(struct fc_request *fp)
{
        ASSERT(fc_initialized);
        ASSERT(fp);
        ASSERT(fp->busy == FC_R_BUSY);

        mutex_enter(&fc_request_lock);
        fp->busy = FC_R_DONE;
        mutex_exit(&fc_request_lock);

        cv_broadcast(&fc_request_cv);
}

/*
 * Generic resource list management subroutines
 */
void
fc_add_resource(fco_handle_t rp, struct fc_resource *ip)
{
        ASSERT(rp);
        ASSERT(ip);

        mutex_enter(&fc_resource_lock);
        ip->next = NULL;
        if (rp->head != NULL)
                ip->next = rp->head;
        rp->head = ip;
        mutex_exit(&fc_resource_lock);
}

void
fc_rem_resource(fco_handle_t rp, struct fc_resource *ip)
{
        struct fc_resource *fp;

        ASSERT(rp);
        ASSERT(ip);

        if (rp->head == NULL)  {
                cmn_err(CE_CONT, "fc_rem_resource: NULL list head!\n");
                return;
        }

        mutex_enter(&fc_resource_lock);
        if (rp->head == ip) {
                rp->head = ip->next;
                mutex_exit(&fc_resource_lock);
                return;
        }

        for (fp = rp->head; fp && (fp->next != ip); fp = fp->next)
                /* empty */;

        if (fp == NULL)  {
                mutex_exit(&fc_resource_lock);
                cmn_err(CE_CONT, "fc_rem_resource: Item not on list!\n");
                return;
        }

        fp->next = ip->next;
        mutex_exit(&fc_resource_lock);
}

/*ARGSUSED*/
void
fc_lock_resource_list(fco_handle_t rp)
{
        mutex_enter(&fc_resource_lock);
}

/*ARGSUSED*/
void
fc_unlock_resource_list(fco_handle_t rp)
{
        mutex_exit(&fc_resource_lock);
}

/*
 * Common helper ops and subroutines
 */
/*ARGSUSED*/
int
fc_syntax_error(fc_ci_t *cp, char *msg)
{
        cp->error = fc_int2cell(-1);
        cp->nresults = fc_int2cell(0);
        return (0);
}

/*ARGSUSED*/
int
fc_priv_error(fc_ci_t *cp, char *msg)
{
        cp->priv_error = fc_int2cell(-1);
        cp->error = fc_int2cell(0);
        cp->nresults = fc_int2cell(0);
        return (0);
}

/*ARGSUSED*/
int
fc_success_op(dev_info_t *ap, fco_handle_t handle, fc_ci_t *cp)
{
        cp->priv_error = cp->error = fc_int2cell(0);
        return (0);
}

/*
 * fc_fail_op: This 'handles' a request by specifically failing it,
 * as opposed to not handling it and returning '-1' to indicate
 * 'service unknown' and allowing somebody else in the chain to
 * handle it.
 */
/*ARGSUSED*/
int
fc_fail_op(dev_info_t *ap, fco_handle_t handle, fc_ci_t *cp)
{
        cmn_err(CE_CONT, "fcode ops: fail service name <%s>\n",
            (char *)fc_cell2ptr(cp->svc_name));

        cp->nresults = fc_int2cell(0);
        cp->error = fc_int2cell(-1);
        return (0);
}

/*
 * Functions to manage the set of handles we give to the interpreter.
 * The handles are opaque and internally represent dev_info_t pointers.
 */
struct fc_phandle_entry **
fc_handle_to_phandle_head(fco_handle_t rp)
{
        while (rp->next_handle)
                rp = rp->next_handle;

        return (&rp->ptable);
}

/*ARGSUSED*/
void
fc_phandle_table_alloc(struct fc_phandle_entry **head)
{
}

void
fc_phandle_table_free(struct fc_phandle_entry **head)
{
        struct fc_phandle_entry *ip, *np;

        /*
         * Free each entry in the table.
         */
        for (ip = *head; ip; ip = np) {
                np = ip->next;
                kmem_free(ip, sizeof (struct fc_phandle_entry));
        }
        *head = NULL;
}

dev_info_t *
fc_phandle_to_dip(struct fc_phandle_entry **head, fc_phandle_t handle)
{
        struct fc_phandle_entry *ip;

        mutex_enter(&fc_hash_lock);

        for (ip = *head; ip; ip = ip->next)
                if (ip->h == handle)
                        break;

        mutex_exit(&fc_hash_lock);

        return (ip ? ip->dip : NULL);
}

fc_phandle_t
fc_dip_to_phandle(struct fc_phandle_entry **head, dev_info_t *dip)
{
        struct fc_phandle_entry *hp, *np;
        fc_phandle_t h;

        ASSERT(dip);
        h = (fc_phandle_t)ddi_get_nodeid(dip);

        /*
         * Just in case, allocate a new entry ...
         */
        np = kmem_zalloc(sizeof (struct fc_phandle_entry), KM_SLEEP);

        mutex_enter(&fc_hash_lock);

        /*
         * If we already have this dip in the table, just return the handle
         */
        for (hp = *head; hp; hp = hp->next) {
                if (hp->dip == dip) {
                        mutex_exit(&fc_hash_lock);
                        kmem_free(np, sizeof (struct fc_phandle_entry));
                        return (h);
                }
        }

        /*
         * Insert this entry to the list of known entries
         */
        np->next = *head;
        np->dip = dip;
        np->h = h;
        *head = np;
        mutex_exit(&fc_hash_lock);
        return (h);
}

/*
 * We won't need this function once the ddi is modified to handle
 * unique non-prom nodeids.  For now, this allows us to add a given
 * nodeid to the device tree without dereferencing the value in the
 * devinfo node, so we have a parallel mechanism.
 */
void
fc_add_dip_to_phandle(struct fc_phandle_entry **head, dev_info_t *dip,
    fc_phandle_t h)
{
        struct fc_phandle_entry *hp, *np;

        ASSERT(dip);

        /*
         * Just in case, allocate a new entry ...
         */
        np = kmem_zalloc(sizeof (struct fc_phandle_entry), KM_SLEEP);

        mutex_enter(&fc_hash_lock);

        /*
         * If we already have this dip in the table, just return the handle
         */
        for (hp = *head; hp; hp = hp->next) {
                if (hp->dip == dip) {
                        mutex_exit(&fc_hash_lock);
                        kmem_free(np, sizeof (struct fc_phandle_entry));
                        return;
                }
        }

        /*
         * Insert this entry to the list of known entries
         */
        np->next = *head;
        np->dip = dip;
        np->h = h;
        *head = np;
        mutex_exit(&fc_hash_lock);
}

/*
 * Functions to manage our copy of our subtree.
 *
 * The head of the device tree is always stored in the last 'handle'
 * in the handle chain.
 */
struct fc_device_tree **
fc_handle_to_dtree_head(fco_handle_t rp)
{
        while (rp->next_handle)
                rp = rp->next_handle;

        return (&rp->dtree);
}

struct fc_device_tree *
fc_handle_to_dtree(fco_handle_t rp)
{
        struct fc_device_tree **head = fc_handle_to_dtree_head(rp);

        return (*head);
}

/*
 * The root of the subtree is the attachment point ...
 * Thus, there is never an empty device tree.
 */
void
fc_create_device_tree(dev_info_t *ap, struct fc_device_tree **head)
{
        struct fc_device_tree *dp;

        dp = kmem_zalloc(sizeof (struct fc_device_tree), KM_SLEEP);
        dp->dip = ap;
        *head = dp;
}

#ifdef  notdef
static void
fc_remove_subtree(struct fc_device_tree *dp)
{
        struct fc_device_tree *np;

        if (dp->child) {
                fc_remove_subtree(dp->child);
                dp->child = NULL;
        }

        /*
         * Remove each peer node, working our way backwards from the
         * last peer node to the first peer node.
         */
        if (dp->peer != NULL) {
                for (np = dp->peer; np->peer; np = dp->peer) {
                        for (/* empty */; np->peer; np = np->peer)
                                /* empty */;
                        fc_remove_subtree(np->peer);
                        np->peer = NULL;
                }
                fc_remove_subtree(dp->peer)
                dp->peer = NULL;
        }

        ASSERT((dp->child == NULL) && (dp->peer == NULL));
        kmem_free(dp, sizeof (struct fc_device_tree));
}

void
fc_remove_device_tree(struct fc_device_tree **head)
{
        ASSERT(head && (*head != NULL));

        fc_remove_subtree(*head);
        *head = NULL;
}
#endif  /* notdef */

void
fc_remove_device_tree(struct fc_device_tree **head)
{
        struct fc_device_tree *dp;

        ASSERT(head && (*head != NULL));

        dp = *head;

        if (dp->child)
                fc_remove_device_tree(&dp->child);

        if (dp->peer)
                fc_remove_device_tree(&dp->peer);

        ASSERT((dp->child == NULL) && (dp->peer == NULL));

        kmem_free(dp, sizeof (struct fc_device_tree));
        *head = NULL;
}

struct fc_device_tree *
fc_find_node(dev_info_t *dip, struct fc_device_tree *hp)
{
        struct fc_device_tree *p;

        while (hp) {
                if (hp->dip == dip)
                        return (hp);

                if (hp->child)
                        if ((p = fc_find_node(dip, hp->child)) != NULL)
                                return (p);

                hp = hp->peer;
        }
        return (NULL);
}

void
fc_add_child(dev_info_t *child, dev_info_t *parent, struct fc_device_tree *hp)
{
        struct fc_device_tree *p, *q;

        q = kmem_zalloc(sizeof (struct fc_device_tree), KM_SLEEP);
        q->dip = child;

        mutex_enter(&fc_device_tree_lock);

#ifdef  DEBUG
        /* XXX: Revisit ASSERT vs PANIC */
        p = fc_find_node(child, hp);
        ASSERT(p == NULL);
#endif

        p = fc_find_node(parent, hp);
        ASSERT(p != NULL);

        q->peer = p->child;
        p->child = q;

        mutex_exit(&fc_device_tree_lock);
}

void
fc_remove_child(dev_info_t *child, struct fc_device_tree *head)
{
        struct fc_device_tree *p, *c, *n;
        dev_info_t *parent = ddi_get_parent(child);

        mutex_enter(&fc_device_tree_lock);

        p = fc_find_node(parent, head);
        ASSERT(p != NULL);

        /*
         * Find the child within the parent's subtree ...
         */
        c = fc_find_node(child, p);
        ASSERT(c != NULL);
        ASSERT(c->child == NULL);

        /*
         * If it's the first child, remove it, otherwise
         * remove it from the child's peer list.
         */
        if (p->child == c) {
                p->child = c->peer;
        } else {
                int found = 0;
                for (n = p->child; n->peer; n = n->peer) {
                        if (n->peer == c) {
                                n->peer = c->peer;
                                found = 1;
                                break;
                        }
                }
                if (!found)
                        cmn_err(CE_PANIC, "fc_remove_child: not found\n");
        }
        mutex_exit(&fc_device_tree_lock);

        kmem_free(c, sizeof (struct fc_device_tree));
}

dev_info_t *
fc_child_node(dev_info_t *parent, struct fc_device_tree *hp)
{
        struct fc_device_tree *p;
        dev_info_t *dip = NULL;

        mutex_enter(&fc_device_tree_lock);
        p = fc_find_node(parent, hp);
        if (p && p->child)
                dip = p->child->dip;
        mutex_exit(&fc_device_tree_lock);

        return (dip);
}

dev_info_t *
fc_peer_node(dev_info_t *devi, struct fc_device_tree *hp)
{
        struct fc_device_tree *p;
        dev_info_t *dip = NULL;

        mutex_enter(&fc_device_tree_lock);
        p = fc_find_node(devi, hp);
        if (p && p->peer)
                dip = p->peer->dip;
        mutex_exit(&fc_device_tree_lock);

        return (dip);
}