/*
 * 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.
 */

/*
 * Retrieval of the DIMM serial number from data encoded in the SPD and
 * SEEPROM formats.
 */

#include <mem_spd.h>
#include <mem_seeprom.h>
#include <mem.h>

#include <fm/fmd_fmri.h>

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <strings.h>
#include <sys/byteorder.h>
#include <sys/stat.h>
#include <sys/types.h>

#define	BUFSIZ_SPD	256
#define	BUFSIZ_SEEPROM	8192

/*
 * SEEPROMs are composed of self-describing containers.  The first container,
 * starting at offset 0, is r/w.  The second container, starting at 0x1800, is
 * r/o, and contains identification information supplied by the manufacturer.
 */
#define	SEEPROM_OFFSET_RO	0x1800

static int
mem_get_spd_serid(const char *buf, size_t bufsz, char *serid, size_t seridsz)
{
	static const char hex_digits[] = "0123456789ABCDEF";
	spd_data_t *spd = (spd_data_t *)buf;
	char *c;
	int i;

	if (bufsz < sizeof (spd_data_t))
		return (fmd_fmri_set_errno(EINVAL));

	if (seridsz < sizeof (spd->asmb_serial_no) * 2 + 1)
		return (fmd_fmri_set_errno(EINVAL));

	for (c = serid, i = 0; i < sizeof (spd->asmb_serial_no); i++) {
		*c++ = hex_digits[spd->asmb_serial_no[i] >> 4];
		*c++ = hex_digits[spd->asmb_serial_no[i] & 0xf];
	}
	*c = '\0';

	return (0);
}

static void *
seeprom_seg_lookup(const char *buf, size_t bufsz, char *segname, size_t *segszp)
{
	seeprom_container_t *sc;
	seeprom_seg_t *segp, seg;
	int sidx;

	if (strlen(segname) != sizeof (seg.sees_name))
		return (NULL);

	sc = (seeprom_container_t *)(buf + SEEPROM_OFFSET_RO);

	/* Validate sc size then dereference it */
	if (bufsz < SEEPROM_OFFSET_RO + sizeof (seeprom_container_t) ||
	    bufsz < SEEPROM_OFFSET_RO + sizeof (seeprom_container_t) +
	    sc->seec_contsz)
		return (NULL);

	if (sc->seec_tag == 0 || sc->seec_contsz == 0 ||
	    sc->seec_nsegs == 0)
		return (NULL);

	for (sidx = 0; sidx < sc->seec_nsegs; sidx++) {
		/* LINTED - pointer alignment */
		segp = ((seeprom_seg_t *)(sc + 1)) + sidx;

		bcopy(segp, &seg, sizeof (seeprom_seg_t));
		seg.sees_segoff = ntohs(seg.sees_segoff);
		seg.sees_seglen = ntohs(seg.sees_seglen);

		if (bufsz < seg.sees_segoff + seg.sees_seglen)
			return (NULL);

		if (strncmp(segname, seg.sees_name,
		    sizeof (seg.sees_name)) == 0) {
			*segszp = seg.sees_seglen;
			return ((void *)(buf + seg.sees_segoff));
		}

	}

	return (NULL);
}

static int
mem_get_seeprom_serid(const char *buf, size_t bufsz, char *serid,
    size_t seridsz)
{
	seeprom_seg_sd_t *sd;
	size_t segsz;

	if (seridsz < sizeof (sd->seesd_sun_sno) + 1)
		return (fmd_fmri_set_errno(EINVAL));

	if ((sd = seeprom_seg_lookup(buf, bufsz, "SD", &segsz)) == NULL)
		return (fmd_fmri_set_errno(EINVAL));

	if (segsz < sizeof (seeprom_seg_sd_t))
		return (fmd_fmri_set_errno(EINVAL));

	bcopy(sd->seesd_sun_sno, serid, sizeof (sd->seesd_sun_sno));
	serid[sizeof (sd->seesd_sun_sno)] = '\0';

	return (0);
}

int
mem_get_serid(const char *device, char *serid, size_t seridsz)
{
	char buf[8192];
	int fd;
	ssize_t sz;

	if ((fd = open(device, O_RDONLY)) < 0)
		return (-1); /* errno is set for us */

	if ((sz = read(fd, buf, sizeof (buf))) < 0) {
		int err = errno;
		(void) close(fd);
		return (fmd_fmri_set_errno(err));
	}

	(void) close(fd);

	switch (sz) {
	case BUFSIZ_SPD:
		return (mem_get_spd_serid(buf, BUFSIZ_SPD, serid, seridsz));
	case BUFSIZ_SEEPROM:
		return (mem_get_seeprom_serid(buf, BUFSIZ_SEEPROM, serid,
		    seridsz));
	default:
		return (fmd_fmri_set_errno(EINVAL));
	}
}