/*
 * 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 (c) 1996-1998 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stddef.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <sys/param.h>
#include <sys/obpdefs.h>
#include <sys/fhc.h>
#include <sys/ac.h>
#include <sys/sysctrl.h>
#include <sys/openpromio.h>
#include "mema_prom.h"
#include <config_admin.h>


/*
 * PROM access routines to get and set disabled lists
 * Based on code in the usr/src/cmd/eeprom directory.
 */
#define PROMDEV         "/dev/openprom"
/*
 * 128 is the size of the largest (currently) property name
 * 8192 - MAXPROPSIZE - sizeof (int) is the size of the largest
 * (currently) property value, viz. nvramrc.
 * the sizeof(u_int) is from struct openpromio
 */

#define MAXPROPSIZE     128
#define MAXNAMESIZE     MAXPROPSIZE
#define MAXVALSIZE      (8192 - MAXPROPSIZE - sizeof (u_int))
#define BUFSIZE         (MAXPROPSIZE + MAXVALSIZE + sizeof (u_int))
typedef union {
        char buf[BUFSIZE];
        struct openpromio opp;
} Oppbuf;
#define PROP_MEMORY_LIST        "disabled-memory-list"

static int prom_read_one(mema_disabled_t *, int, int, char *, u_int);
static int prom_write_one(mema_disabled_t *, int, int, char *, u_int);

int
prom_read_disabled_list(mema_disabled_t *dp, int bd)
{
        int prom_fd;
        int ret;

        (void) memset((void *)dp, 0, sizeof (*dp));
        prom_fd = open(PROMDEV, O_RDONLY);
        if (prom_fd == -1) {
                return (0);
        }
        ret = prom_read_one(dp, bd, prom_fd,
            PROP_MEMORY_LIST, PROM_MEMORY_DISABLED);
        (void) close(prom_fd);
        return (ret);
}

int
prom_write_disabled_list(mema_disabled_t *dp, int bd)
{
        int prom_fd;
        int ret;

        prom_fd = open(PROMDEV, O_RDWR);
        if (prom_fd == -1) {
                return (0);
        }
        ret = prom_write_one(dp, bd, prom_fd,
            PROP_MEMORY_LIST, PROM_MEMORY_DISABLED);
        (void) close(prom_fd);
        return (ret);
}

static int
prom_read_one(
        mema_disabled_t *dp,
        int bd,
        int prom_fd,
        char *var,
        u_int bit)
{
        Oppbuf oppbuf;
        struct openpromio *opp = &oppbuf.opp;
        int ret;

        (void) memset((void *)&oppbuf, 0, sizeof (oppbuf));
        (void) strncpy(opp->oprom_array, var, MAXNAMESIZE);
        opp->oprom_size = MAXVALSIZE;
        if (ioctl(prom_fd, OPROMGETOPT, opp) == -1) {
                ret = 0;
        } else
        if (opp->oprom_size == 0) {
                /* Not a failure - just not set to anything */
                ret = 1;
        } else {
                char *cp;
                int board;

                ret = 1;
                for (cp = opp->oprom_array; *cp != '\0'; cp++) {
                        switch (*cp) {
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                                board = *cp - '0';
                                break;
                        case 'a':
                        case 'b':
                        case 'c':
                        case 'd':
                        case 'e':
                        case 'f':
                                board = *cp - 'a' + 10;
                                break;
                        case 'A':
                        case 'B':
                        case 'C':
                        case 'D':
                        case 'E':
                        case 'F':
                                board = *cp - 'A' + 10;
                                break;
                        default:
                                /* Ignore bad characters. */
                                /* TODO: maybe should set ret to 0? */
                                board = -1;
                                break;
                        }
                        if (board == bd)
                                *dp |= bit;
                }
        }
        return (ret);
}

static int
prom_write_one(
        mema_disabled_t *dp,
        int bd,
        int prom_fd,
        char *var,
        u_int bit)
{
        Oppbuf in_oppbuf;
        struct openpromio *in_opp = &in_oppbuf.opp;
        Oppbuf oppbuf;
        struct openpromio *opp = &oppbuf.opp;
        int ret;
        char *cp;

        /* Setup output buffer. */
        (void) memset((void *)&oppbuf, 0, sizeof (oppbuf));
        (void) strncpy(opp->oprom_array, var, MAXNAMESIZE);
        opp->oprom_size = strlen(var) + 1;
        cp = opp->oprom_array + opp->oprom_size;

        /*
         * First read the existing list, filtering out 'bd' if 'bit'
         * not set.
         */
        (void) memset((void *)&in_oppbuf, 0, sizeof (in_oppbuf));
        (void) strncpy(in_opp->oprom_array, var, MAXNAMESIZE);
        in_opp->oprom_size = MAXVALSIZE;
        if (ioctl(prom_fd, OPROMGETOPT, in_opp) != -1 &&
            in_opp->oprom_size != 0) {
                char *icp;
                int board;

                for (icp = in_opp->oprom_array; *icp != '\0'; icp++) {
                        switch (*icp) {
                        case '0': case '1': case '2': case '3':
                        case '4': case '5': case '6': case '7':
                        case '8': case '9':
                                board = *icp - '0';
                                break;
                        case 'a': case 'b': case 'c':
                        case 'd': case 'e': case 'f':
                                board = *icp - 'a' + 10;
                                break;
                        case 'A': case 'B': case 'C':
                        case 'D': case 'E': case 'F':
                                board = *icp - 'A' + 10;
                                break;
                        default:
                                /* Ignore bad characters. */
                                continue;
                        }
                        /* If enabling this board ... */
                        if (board == bd && (*dp & bit) == 0)
                                continue;
                        *cp++ = "0123456789abcdef"[board];
                        opp->oprom_size++;
                }
        }

        if ((*dp & bit) != 0) {
                *cp++ = "0123456789abcdef"[bd];
                opp->oprom_size++;
        }
        if (ioctl(prom_fd, OPROMSETOPT, opp) == -1) {
                ret = 0;
        } else {
                ret = 1;
        }

        return (ret);
}

/*
 * The PROM only has board-level disable of memory.  If two banks are present
 * on the board, both are either enabled or disabled at boot.
 * The caller of this routine must set the PROM_MEMORY_PRESENT bits
 * before calling this function.
 */

/*ARGSUSED*/
int
prom_viable_disabled_list(mema_disabled_t *dp)
{
#ifdef  XXX
        int board;

        for (board = 0; board < MAX_BOARDS; board++) {
                if ((dp->bank_A[board] & PROM_MEMORY_PRESENT) != 0 &&
                    (dp->bank_B[board] & PROM_MEMORY_PRESENT) != 0 &&
                    (dp->bank_A[board] & PROM_MEMORY_DISABLED) !=
                    (dp->bank_B[board] & PROM_MEMORY_DISABLED)) {
                        return (0);
                }
        }
#endif
        return (1);
}