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

#include "fru_access_impl.h"

static uchar_t                  sp_sec_hdr[] = SP_SEC_HDR;
static uchar_t                  sp_seg_hdr[] = SP_SEG_HDR;
static uchar_t                  sp_seg_body[] = SP_DATA;

/*
 * function to return section header for simulated SPD fruid
 *
 * parameters:
 *      sec_hdr         buffer to receive section header
 *      sec_hdr_len     size of buffer sec_hdr
 * return value:
 *      size of returned data (0 if sec_hdr_len too small)
 */
size_t
get_sp_sec_hdr(void *sec_hdr, size_t sec_hdr_len)
{
        if (sec_hdr_len < sizeof (sp_sec_hdr))
                return (0);
        (void) memcpy(sec_hdr, sp_sec_hdr, sizeof (sp_sec_hdr));
        return (sizeof (sp_sec_hdr));
}

/*
 * function to return segment header for simulated SPD fruid
 *
 * parameters:
 *      seg_hdr         buffer to receive segment header
 *      seg_hdr_len     size of buffer seg_hdr
 * return value:
 *      size of returned data (0 if seg_hdr_len too small)
 */
size_t
get_sp_seg_hdr(void *seg_hdr, size_t seg_hdr_len)
{
        if (seg_hdr_len < sizeof (sp_seg_hdr))
                return (0);
        (void) memcpy(seg_hdr, sp_seg_hdr, sizeof (sp_seg_hdr));
        return (sizeof (sp_seg_hdr));
}

/*
 * Function to convert SPD data into SPD fruid segment.
 * The segment comprises two tagged records: DIMM_Capacity and SPD_R.
 *
 * DIMM_Capacity is a text string showing the total usable size of the
 * DIMM (i.e. not including error correction bits). This record is derived
 * from module row density and number of rows.
 *
 * SPD_R contains the entire SPD data area from the DIMM. It is slightly
 * massaged to make it easier to display:
 * bytes  0 -  63 are presented as is
 * bytes 64 -  71 (JEDEC code) are compressed into 2 bytes, matching the
 *                format used in ManR
 * bytes 72 -  92 are copied as is (to bytes 66 - 86)
 * byte  93       year of manufacture is expanded to a 2 byte (big endian)
 *                field which includes the century (to bytes 87 - 88)
 * bytes 94 - 127 are copied as is (to bytes 89 - 122)
 *
 * parameters:
 *      spd_data        pointer to SPD data
 *      spd_data_len    length of supplied SPD data
 *      sp_seg_ptr      pointer to receive address of converted data
 *      sp_seg_len      pointer for size of converted data
 * return value:
 *      0       - success
 *      NZ      - error code
 */
int
cvrt_dim_data(const char *spd_data, size_t spd_data_len, uchar_t **sp_seg_ptr,
    size_t *sp_seg_len)
{
        int             c;
        ushort_t        year;
        int             capacity;
        spd_data_t      *spd;
        uint32_t        sum;

        if (spd_data_len < sizeof (spd_data_t))
                return (EINVAL);

        spd = (spd_data_t *)spd_data;
        *sp_seg_ptr = malloc(sizeof (sp_seg_body));

        if (*sp_seg_ptr == NULL)
                return (ENOMEM);

        /* set up template for SP seg */
        (void) memcpy(*sp_seg_ptr, sp_seg_body, sizeof (sp_seg_body));

        year = spd->manu_year;

        if (year < 80)
                year += 2000;
        else
                year += 1900;

        /*
         * move first 64 bytes of SPD data into SPD-R record
         */
        (void) memcpy(*sp_seg_ptr + SPD_R_OFF, spd_data, 64);

        /*
         * re-write full data width as big endian
         */
        (*sp_seg_ptr + SPD_R_OFF + DATA_WIDTH)[0] = spd->ms_data_width;
        (*sp_seg_ptr + SPD_R_OFF + DATA_WIDTH)[1] = spd->ls_data_width;

        /*
         * construct Sun compressed encoding for JEDEC code
         */
        for (c = 0; c < sizeof (spd->jedec) - 1; c++) {
                if (spd->jedec[c] != 0x7F)
                        break;
        }

        (*sp_seg_ptr)[SPD_R_OFF + MANUF_ID] = (uchar_t)c;
        (*sp_seg_ptr)[SPD_R_OFF + MANUF_ID + 1] = (uchar_t)spd->jedec[c];

        /*
         * move other fields in place
         */
        (void) memcpy(*sp_seg_ptr + SPD_R_OFF + MANUF_LOC,
            &spd->manu_loc, MANUF_YEAR - MANUF_LOC);

        (*sp_seg_ptr + SPD_R_OFF + MANUF_YEAR)[0] = (uchar_t)(year >> 8);
        (*sp_seg_ptr + SPD_R_OFF + MANUF_YEAR)[1] = (uchar_t)year;

        (void) memcpy(*sp_seg_ptr + SPD_R_OFF + MANUF_WEEK,
            &spd->manu_week, SPD_R_LEN - MANUF_WEEK);

        /*
         * calculate the capacity and insert into capacity record
         */
        if ((spd->spd_rev >> 4) > 1) {
                (void) snprintf((char *)(*sp_seg_ptr + DIMM_CAP_OFF), 8,
                    "ver %x.%x", spd->spd_rev >> 4, spd->spd_rev & 0x0f);
        } else if ((spd->memory_type != SPDMEM_SDRAM) &&
            (spd->memory_type != SPDMEM_SDRAM_DDR) &&
            (spd->memory_type != SPDMEM_DDR2_SDRAM)) {
                /*
                 * can't handle this memory type
                 */
                ((char *)(*sp_seg_ptr))[DIMM_CAP_OFF] = '\0';
        } else if ((((spd->ms_data_width << 8) | spd->ls_data_width) == 72) &&
            ((spd->n_rows & 0xf0) == 0) && ((spd->n_cols & 0xf0) == 0)) {
                /*
                 * OK it's 72-bits wide with equal width banks
                 */
                char m_or_g = 'G';
                capacity = spd->mod_row_density;
                if (((spd->memory_type == SPDMEM_DDR2_SDRAM) &&
                    (capacity > 16)) ||
                    (capacity > 4)) {
                        capacity *= 4;
                        m_or_g = 'M';
                }
                c = spd->n_mod_rows;
                if (spd->memory_type == SPDMEM_DDR2_SDRAM) {
                        c &= 7;
                        c++;
                }
                capacity *= c;
                if ((m_or_g == 'M') && (capacity >= 1024)) {
                        capacity /= 1024;
                        m_or_g = 'G';
                }
                (void) snprintf((char *)(*sp_seg_ptr + DIMM_CAP_OFF), 8,
                    "%d %cB", capacity, m_or_g);
        } else {
                ((char *)(*sp_seg_ptr))[DIMM_CAP_OFF] = '\0';
        }

        /*
         * finally, set the checksum
         */
        sum = compute_crc32(*sp_seg_ptr, sizeof (sp_seg_body) - 5);
        for (c = 0; c < 4; c++) {
                (*sp_seg_ptr + sizeof (sp_seg_body) - 4)[c] =
                    ((char *)(&sum))[c];
        }
        *sp_seg_len = sizeof (sp_seg_body);
        return (0);
}

/*
 * get_spd_data - reads raw data from container
 * parameters:
 *      fd              file descriptor for SPD device
 *      ctr_offset      container offset
 *      ctr_len         container size
 *      spd_data        buffer to receive SPD data (length ctr_len)
 * return value:
 *      0       - success
 *      NZ      - error code
 */
int
get_spd_data(int fd, char *spd_data, size_t ctr_len, off_t ctr_offset)
{
        if (ctr_len < sizeof (spd_data_t))
                return (EINVAL);

        (void) memset(spd_data, 0, ctr_len);

        if (pread(fd, spd_data, sizeof (spd_data_t), ctr_offset) !=
            sizeof (spd_data_t))
                return (EIO);
        return (0);
}