/*
 * 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 2000, 2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * PICL Daktari platform plug-in to create environment tree nodes.
 */

#include        <poll.h>
#include        <picl.h>
#include        <picltree.h>
#include        <stdio.h>
#include        <time.h>
#include        <fcntl.h>
#include        <unistd.h>
#include        <stdlib.h>
#include        <libintl.h>
#include        <limits.h>
#include        <ctype.h>
#include        <pthread.h>
#include        <errno.h>
#include        <syslog.h>
#include        <sys/types.h>
#include        <sys/systeminfo.h>
#include        <psvc_objects.h>
#include        <strings.h>

/*LINTLIBRARY*/

#define BUFSZ   512

static psvc_opaque_t hdlp;

#define PSVC_PLUGIN_VERSION     PICLD_PLUGIN_VERSION_1

#pragma init(psvc_psr_plugin_register)  /* place in .init section */


struct proj_prop {      /* projected property */
        picl_prophdl_t  handle;
        picl_nodehdl_t  dst_node;
        char            name[32];
};

typedef struct {
        char            name[32];
        picl_nodehdl_t  node;
} picl_psvc_t;

extern struct handle {
        uint32_t        obj_count;
        picl_psvc_t *objects;
        FILE *fp;
} psvc_hdl;

extern struct proj_prop *prop_list;
extern uint32_t proj_prop_count;

void psvc_psr_plugin_init(void);
void psvc_psr_plugin_fini(void);

picld_plugin_reg_t psvc_psr_reg = {
        PSVC_PLUGIN_VERSION,
        PICLD_PLUGIN_CRITICAL,
        "PSVC_PSR",
        psvc_psr_plugin_init,
        psvc_psr_plugin_fini
};


#define PSVC_INIT_MSG           gettext("%s: Error in psvc_init(): %s\n")
#define PTREE_DELETE_NODE_MSG   gettext("%s: ptree_delete_node() failed: %s\n")
#define PTREE_GET_NODE_MSG                      \
        gettext("%s: ptree_get_node_by_path() failed for %s: %s\n")
#define INVALID_FILE_FORMAT_MSG         gettext("%s: Invalid file format\n")
#define ID_NOT_FOUND_MSG        gettext("%s: Can't determine id of %s\n")
#define NODE_NOT_FOUND_MSG      gettext("%s: Can't determine node of %s\n")
#define SIZE_NOT_FOUND_MSG      gettext("%s: Couldn't determine size of %s\n")
#define PTREE_CREATE_PROP_FAILED_MSG            \
        gettext("%s: ptree_create_prop failed, %s\n")
#define PTREE_ADD_PROP_FAILED_MSG gettext("%s: ptree_add_prop: %s\n")
#define FANSPEED_PROP_NOT_FOUND_MSG             \
        gettext("%s: Can't find property fan-speed\n")
#define FANSPEED_PROP_DELETE_FAILED_MSG         \
        gettext("%s: Can't delete property fan-speed\n")

static int32_t count_records(FILE *fp, char *end, uint32_t *countp)
{
        long first_record;
        char *ret;
        char buf[BUFSZ];
        uint32_t count = 0;

        first_record = ftell(fp);

        while ((ret = fgets(buf, BUFSZ, fp)) != NULL) {
                if (strncmp(end, buf, strlen(end)) == 0)
                        break;
                ++count;
        }

        if (ret == NULL) {
                errno = EINVAL;
                return (-1);
        }

        fseek(fp, first_record, SEEK_SET);
        *countp = count;
        return (0);
}

/*
 * Find start of a section within the config file,
 * Returns number of records in the section.
 * FILE *fd is set to first data record within section.
 */
static int32_t
find_file_section(FILE *fd, char *start)
{
        char *ret;
        char buf[BUFSZ];
        char name[32];
        int found;

        fseek(fd, 0, SEEK_SET);
        while ((ret = fgets(buf, BUFSZ, fd)) != NULL) {
                if (strncmp(start, buf, strlen(start)) == 0)
                        break;
        }

        if (ret == NULL) {
                errno = EINVAL;
                return (-1);
        }

        found = sscanf(buf, "%s", name);
        if (found != 1) {
                errno = EINVAL;
                return (-1);
        } else {
                return (0);
        }

}

static int32_t name_compare_bsearch(char *s1, picl_psvc_t *s2)
{
        return (strcmp(s1, s2->name));
}

static void init_err(char *fmt, char *arg1, char *arg2)
{
        char msg[256];

        sprintf(msg, fmt, arg1, arg2);
        syslog(LOG_ERR, msg);
}

static int
projected_lookup(picl_prophdl_t proph, struct proj_prop **dstp)
{
        int i;

        for (i = 0; i < proj_prop_count; ++i) {
                if (prop_list[i].handle == proph) {
                        *dstp = &prop_list[i];
                        return (PICL_SUCCESS);
                }
        }

        return (PICL_INVALIDHANDLE);
}

int
fan_speed_read(ptree_rarg_t *rarg, void *buf)
{
        struct proj_prop *dstinfo;
        int err;
        ptree_propinfo_t propinfo;
        picl_prophdl_t assoctbl;

        err = projected_lookup(rarg->proph, &dstinfo);
        if (err != PSVC_SUCCESS) {
                return (PICL_FAILURE);
        }


        /* see if there's a tach switch */
        err = ptree_get_propval_by_name(rarg->nodeh,
            "PSVC_FAN_PRIM_SEC_SELECTOR", &assoctbl, sizeof (assoctbl));

        if (err != PICL_SUCCESS) {
                return (err);
        } else {
                char switch_state[32], temp_state[32];
                uint64_t features;
                picl_prophdl_t entry;
                picl_nodehdl_t tach_switch;
                char id[PICL_PROPNAMELEN_MAX];
                char name[PICL_PROPNAMELEN_MAX];

                err = ptree_get_next_by_row(assoctbl, &entry);
                if (err != PICL_SUCCESS) {
                        return (err);
                }
                err = ptree_get_propval(entry, &tach_switch,
                        sizeof (tach_switch));
                if (err != PICL_SUCCESS) {
                        return (err);
                }

                err = ptree_get_propval_by_name(rarg->nodeh, PICL_PROP_NAME,
                        &id, PICL_PROPNAMELEN_MAX);

                err = psvc_get_attr(hdlp, id, PSVC_FEATURES_ATTR, &features);

                if (err != PSVC_SUCCESS) {
                        return (err);
                }
                if (features & PSVC_DEV_PRIMARY) {
                        strlcpy(switch_state, PSVC_SWITCH_ON,
                            sizeof (switch_state));
                } else {
                        strlcpy(switch_state, PSVC_SWITCH_OFF,
                            sizeof (switch_state));
                }

                pthread_mutex_lock(&fan_mutex);

                err = ptree_get_propval_by_name(tach_switch, PICL_PROP_NAME,
                        &name, PICL_PROPNAMELEN_MAX);

                err = ptree_get_propval_by_name(tach_switch, "State",
                        &temp_state, sizeof (temp_state));

                err = psvc_set_attr(hdlp, name, PSVC_SWITCH_STATE_ATTR,
                        &switch_state);

                if (err != PSVC_SUCCESS) {
                        pthread_mutex_unlock(&fan_mutex);
                        return (err);
                }
                (void) poll(NULL, 0, 250);
        }


        err = ptree_get_propinfo(rarg->proph, &propinfo);

        if (err != PICL_SUCCESS) {
                pthread_mutex_unlock(&fan_mutex);
                return (err);
        }

        err = ptree_get_propval_by_name(dstinfo->dst_node,
                dstinfo->name, buf, propinfo.piclinfo.size);
        if (err != PICL_SUCCESS) {
                pthread_mutex_unlock(&fan_mutex);
                return (err);
        }

        pthread_mutex_unlock(&fan_mutex);

        return (PICL_SUCCESS);
}


/* Load projected properties */
/*
 * This Routine Searches through the projected properties section of the conf
 * file and replaces the currently set up values in the CPU and IO Fan Objects
 * Fan-Speed property to Daktari specific values
 */
static void
load_projected_properties(FILE *fp)
{
        int32_t found;
        ptree_propinfo_t propinfo;
        ptree_propinfo_t dstinfo;
        picl_prophdl_t src_prophdl, dst_prophdl;
        picl_nodehdl_t src_node, dst_node;
        int err, i;
        picl_psvc_t *srcobjp, *dstobjp;
        char src[32], dst[256];
        char src_prop[32], dst_prop[32];
        char buf[BUFSZ];
        char *funcname = "load_projected_properties";

        if (find_file_section(fp, "PROJECTED_PROPERTIES") != 0)
                return;

        if (count_records(fp, "PROJECTED_PROPERTIES_END",
                &proj_prop_count) != 0) {
                init_err(INVALID_FILE_FORMAT_MSG, funcname, 0);
                return;
        }


        for (i = 0; i < proj_prop_count; ++i) {
                fgets(buf, BUFSZ, fp);
                found = sscanf(buf, "%s %s %s %s", src, src_prop, dst,
                        dst_prop);
                if (found != 4) {
                        init_err(INVALID_FILE_FORMAT_MSG, funcname, 0);
                        return;
                }
                if (strcmp(src_prop, "Fan-speed") != 0)
                        continue;

                if ((strcmp(src, "IO_BRIDGE_PRIM_FAN") == 0) ||
                        (strcmp(src, "IO_BRIDGE_SEC_FAN") == 0))
                        continue;

                /* find src node */
                if (src[0] == '/') {
                        /* picl node name, outside psvc subtree */
                        err = ptree_get_node_by_path(src, &src_node);
                        if (err != 0) {
                                init_err(NODE_NOT_FOUND_MSG, funcname, src);
                                return;
                        }
                } else {
                        srcobjp = (picl_psvc_t *)bsearch(src, psvc_hdl.objects,
                                psvc_hdl.obj_count, sizeof (picl_psvc_t),
                                (int (*)(const void *, const void *))
                                name_compare_bsearch);
                        if (srcobjp == NULL) {
                                init_err(ID_NOT_FOUND_MSG, funcname, src);
                                return;
                        }
                        src_node = srcobjp->node;
                }

                /*
                 * Get the property Handle for the property names "Fan-Speed"
                 * from the source node
                 */
                err = ptree_get_prop_by_name(src_node, "Fan-speed",
                    &src_prophdl);
                if (err != 0) {
                        init_err(FANSPEED_PROP_NOT_FOUND_MSG, funcname, 0);
                        return;
                }

                /*
                 * Delete the current property Handle as we are going to replace
                 * it's values
                 */
                err = ptree_delete_prop(src_prophdl);
                if (err != 0) {
                        init_err(FANSPEED_PROP_DELETE_FAILED_MSG, funcname, 0);
                        return;
                }

                /* destroy property created by generic plugin */
                ptree_delete_prop(prop_list[i].handle);
                ptree_destroy_prop(prop_list[i].handle);

                /* find dest node */
                if (dst[0] == '/') {
                        /* picl node name, outside psvc subtree */
                        err = ptree_get_node_by_path(dst, &dst_node);
                        if (err != 0) {
                                init_err(NODE_NOT_FOUND_MSG, funcname, dst);
                                return;
                        }
                        prop_list[i].dst_node = dst_node;
                } else {
                        dstobjp = (picl_psvc_t *)bsearch(dst, psvc_hdl.objects,
                                psvc_hdl.obj_count, sizeof (picl_psvc_t),
                                (int (*)(const void *, const void *))
                                name_compare_bsearch);
                        if (dstobjp == NULL) {
                                init_err(ID_NOT_FOUND_MSG, funcname, dst);
                                return;
                        }
                        prop_list[i].dst_node = dstobjp->node;
                        dst_node = dstobjp->node;
                }

                /* determine destination property size */
                err = ptree_get_first_prop(dst_node, &dst_prophdl);
                while (err == 0) {
                        err = ptree_get_propinfo(dst_prophdl, &dstinfo);
                        if (err != 0)
                                break;
                        if (strcmp(dst_prop, dstinfo.piclinfo.name) == 0)
                                break;
                        err = ptree_get_next_prop(dst_prophdl, &dst_prophdl);
                }
                if (err != 0) {
                        init_err(SIZE_NOT_FOUND_MSG, funcname, dst_prop);
                        return;
                }

                propinfo.version = PSVC_PLUGIN_VERSION;
                propinfo.read = fan_speed_read;
                propinfo.write = 0;
                propinfo.piclinfo.type = dstinfo.piclinfo.type;
                propinfo.piclinfo.accessmode = PICL_READ | PICL_VOLATILE;
                propinfo.piclinfo.size = dstinfo.piclinfo.size;
                strcpy(propinfo.piclinfo.name, src_prop);

                err = ptree_create_prop(&propinfo, 0, &src_prophdl);
                if (err != 0) {
                        init_err(PTREE_CREATE_PROP_FAILED_MSG, funcname,
                                picl_strerror(err));
                        return;
                }

                err = ptree_add_prop(src_node, src_prophdl);
                if (err != 0) {
                        init_err(PTREE_ADD_PROP_FAILED_MSG, funcname,
                                picl_strerror(err));
                        return;
                }

                prop_list[i].handle = src_prophdl;
                strcpy(prop_list[i].name, dst_prop);
        }
}


void
psvc_psr_plugin_init(void)
{
        char *funcname = "psvc_psr_plugin_init";
        int32_t i;
        int err;
        boolean_t present;

        /*
         * So the volatile read/write routines can retrieve data from
         * psvc or picl
         */
        err = psvc_init(&hdlp);
        if (err != 0) {
                init_err(PSVC_INIT_MSG, funcname, strerror(errno));
        }

        load_projected_properties(psvc_hdl.fp);

        /*
         * Remove nodes whose devices aren't present from the picl tree.
         */
        for (i = 0; i < psvc_hdl.obj_count; ++i) {
                picl_psvc_t *objp;
                uint64_t features;

                objp = &psvc_hdl.objects[i];

                err = psvc_get_attr(hdlp, objp->name, PSVC_PRESENCE_ATTR,
                        &present);
                if (err != PSVC_SUCCESS)
                        continue;
                err = psvc_get_attr(hdlp, objp->name, PSVC_FEATURES_ATTR,
                        &features);
                if (err != PSVC_SUCCESS)
                        continue;
                if ((features & (PSVC_DEV_HOTPLUG | PSVC_DEV_OPTION)) &&
                        (present == PSVC_ABSENT)) {
                        err = ptree_delete_node(objp->node);
                        if (err != 0) {
                                init_err(PTREE_DELETE_NODE_MSG, funcname,
                                        picl_strerror(err));
                                return;
                        }
                }
        }

        free(psvc_hdl.objects);

}

void
psvc_psr_plugin_fini(void)
{
        psvc_fini(hdlp);
}

void
psvc_psr_plugin_register(void)
{
        picld_plugin_register(&psvc_psr_reg);
}