eeprom.c

操作系统SunOS 4.1.3版本的源码

		 * Recalculate checksum.
		 */
		u_char *cp;
		u_short *wp;

		cp = &ep->ee_diag.eed_chksum[0];
		cp[0] = cp[1] = cp[2] =
		    chksum((u_char *)&ep->ee_diag.eed_hwupdate,
			sizeof (ep->ee_diag) -
			((char *)(&ep->ee_diag.eed_hwupdate) -
			    (char *)(&ep->ee_diag)));
		lseek(fd, (long) ((char *)cp - (char *)ep), 0);
		write(fd, (char *)cp, 3 * sizeof (*cp));
		wp = &ep->ee_diag.eed_wrcnt[0];
		wp[0] = wp[1] = wp[2] = wp[0] + 1;
		lseek(fd, (long) ((char *)wp - (char *)ep), 0);
		write(fd, (char *)wp, 3 * sizeof (*wp));
	}
	close(fd);
}

/*
 * Check the write counts and checksums in *ep.
 * Return 0 on success, 1 if write count or checksum is wrong.
 */

eecheck(ep, ign)
	register struct eeprom *ep;
	int ign;
{
	register u_short *wp;
	register u_char *cp;

	/* check diagnostic area */
	wp = ep->ee_diag.eed_wrcnt;
	if (wp[0] != wp[1] || wp[0] != wp[2]) {
		fprintf(stderr, "eeprom: diagnostic area write count mismatch\n");
		if (!ign)
			return (1);
	}
	cp = ep->ee_diag.eed_chksum;
	if (cp[0] != cp[1] || cp[0] != cp[2]) {
		fprintf(stderr, "eeprom: diagnostic area checksum mismatch\n");
		if (!ign)
			return (1);
	}
	if (chksum((u_char *)&ep->ee_diag.eed_hwupdate, sizeof (ep->ee_diag) -
	    ((char *)(&ep->ee_diag.eed_hwupdate) - (char *)(&ep->ee_diag))) !=
	    cp[0]) {
		fprintf(stderr, "eeprom: diagnostic area checksum wrong\n");
		if (!ign)
			return (1);
	}

	/* check reserved area */
	wp = ep->ee_resv.eev_wrcnt;
	if (wp[0] != wp[1] || wp[0] != wp[2]) {
		fprintf(stderr, "eeprom: reserved area write count mismatch\n");
		if (!ign)
			return (1);
	}
	cp = ep->ee_resv.eev_chksum;
	if (cp[0] != cp[1] || cp[0] != cp[2]) {
		fprintf(stderr, "eeprom: reserved area checksum mismatch\n");
		if (!ign)
			return (1);
	}
	if (chksum((u_char *)&ep->ee_resv.eev_resv[0], sizeof (ep->ee_resv) -
	    ((char *)(&ep->ee_resv.eev_resv[0]) - (char *)(&ep->ee_resv))) !=
	    cp[0]) {
		fprintf(stderr, "eeprom: reserved area checksum wrong\n");
		if (!ign)
			return (1);
	}

	/* check rom area */
	wp = ep->ee_rom.eer_wrcnt;
	if (wp[0] != wp[1] || wp[0] != wp[2]) {
		fprintf(stderr, "eeprom: rom area write count mismatch\n");
		if (!ign)
			return (1);
	}
	cp = ep->ee_rom.eer_chksum;
	if (cp[0] != cp[1] || cp[0] != cp[2]) {
		fprintf(stderr, "eeprom: rom area checksum mismatch\n");
		if (!ign)
			return (1);
	}
	if (chksum((u_char *)&ep->ee_rom.eer_resv[0], sizeof (ep->ee_rom) -
	    ((char *)(&ep->ee_rom.eer_resv[0]) - (char *)(&ep->ee_rom))) !=
	    cp[0]) {
		fprintf(stderr, "eeprom: rom area checksum wrong\n");
		if (!ign)
			return (1);
	}

	/* check software area */
	wp = ep->ee_soft.ees_wrcnt;
	if (wp[0] != wp[1] || wp[0] != wp[2]) {
		fprintf(stderr, "eeprom: software area write count mismatch\n");
		if (!ign)
			return (1);
	}
	cp = ep->ee_soft.ees_chksum;
	if (cp[0] != cp[1] || cp[0] != cp[2]) {
		fprintf(stderr, "eeprom: software area checksum mismatch\n");
		if (!ign)
			return (1);
	}
	if (chksum((u_char *)&ep->ee_soft.ees_resv[0], sizeof (ep->ee_soft) -
	    ((char *)(&ep->ee_soft.ees_resv[0]) - (char *)(&ep->ee_soft))) !=
	    cp[0]) {
		fprintf(stderr, "eeprom: software area checksum wrong\n");
		if (!ign)
			return (1);
	}
	return (0);
}

/*
 * Fix up the checksums if they are wrong.
 */

void
eefix_chksum(ep)
	register struct eeprom *ep;
{
	register u_short *wp;
	register u_char *cp;
	register u_char calc_sum;		/* calculated checksum */
	int fd;

	if ((fd = open(eeprom_dev, 2)) < 0) {
		fprintf(stderr, "%s: open error.", eeprom_dev);
		perror(eeprom_dev);
		exit(1);
	}

	/* check diag area */
	cp = ep->ee_diag.eed_chksum;
	calc_sum =  chksum((u_char *)&ep->ee_diag.eed_hwupdate, 
	    sizeof (ep->ee_diag) -
	    ((char *)(&ep->ee_diag.eed_hwupdate) - (char *)(&ep->ee_diag)));
	if (calc_sum != cp[0] || calc_sum != cp[1] || calc_sum != cp[2]) {
		/* write out the correct checksum */
		cp[0] = cp[1] = cp[2] = calc_sum;
		lseek(fd, (long)((char *)cp - (char *)ep), 0);
		write(fd, (char *)cp, 3 * sizeof (*cp));
		wp = &ep->ee_diag.eed_wrcnt[0];
		wp[0] = wp[1] = wp[2] = wp[0] + 1;	/* inc write cnt */
		lseek(fd, (long)((char *)wp - (char *)ep), 0);
		write(fd, (char *)wp, 3 * sizeof (*wp));
	}

	/* check reserved area */
	cp = ep->ee_resv.eev_chksum;
	calc_sum = chksum((u_char *)&ep->ee_resv.eev_resv[0], 
	    sizeof (ep->ee_resv) -
	    ((char *)(&ep->ee_resv.eev_resv[0]) - (char *)(&ep->ee_resv)));
	if (calc_sum != cp[0] || calc_sum != cp[1] || calc_sum != cp[2]) {
		/* write out the correct checksum */
		cp[0] = cp[1] = cp[2] = calc_sum;
		lseek(fd, (long)((char *)cp - (char *)ep), 0);
		write(fd, (char *)cp, 3 * sizeof (*cp));
		wp = &ep->ee_diag.eed_wrcnt[0];
		wp[0] = wp[1] = wp[2] = wp[0] + 1;	/* inc write cnt */
		lseek(fd, (long)((char *)wp - (char *)ep), 0);
		write(fd, (char *)wp, 3 * sizeof (*wp));
	}

	/* check rom area */
	cp = ep->ee_rom.eer_chksum;
	calc_sum = chksum((u_char *)&ep->ee_rom.eer_resv[0], 
	    sizeof (ep->ee_rom) -
	    ((char *)(&ep->ee_rom.eer_resv[0]) - (char *)(&ep->ee_rom)));
	if (calc_sum != cp[0] || calc_sum != cp[1] || calc_sum != cp[2]) {
		/* write out the correct checksum */
		cp[0] = cp[1] = cp[2] = calc_sum;
		lseek(fd, (long)((char *)cp - (char *)ep), 0);
		write(fd, (char *)cp, 3 * sizeof (*cp));
		wp = &ep->ee_diag.eed_wrcnt[0];
		wp[0] = wp[1] = wp[2] = wp[0] + 1;	/* inc write cnt */
		lseek(fd, (long)((char *)wp - (char *)ep), 0);
		write(fd, (char *)wp, 3 * sizeof (*wp));
	}

	/* check software area */
	cp = ep->ee_soft.ees_chksum;
	calc_sum = chksum((u_char *)&ep->ee_soft.ees_resv[0],
	    sizeof (ep->ee_soft) -
	    ((char *)(&ep->ee_soft.ees_resv[0]) - (char *)(&ep->ee_soft)));
	if (calc_sum != cp[0] || calc_sum != cp[1] || calc_sum != cp[2]) {
		/* write out the correct checksum */
		cp[0] = cp[1] = cp[2] = calc_sum;
		lseek(fd, (long)((char *)cp - (char *)ep), 0);
		write(fd, (char *)cp, 3 * sizeof (*cp));
		wp = &ep->ee_diag.eed_wrcnt[0];
		wp[0] = wp[1] = wp[2] = wp[0] + 1;	/* inc write cnt */
		lseek(fd, (long)((char *)wp - (char *)ep), 0);
		write(fd, (char *)wp, 3 * sizeof (*wp));
	}
	close(fd);
}

u_char
chksum(p, n)
	register u_char *p;
	register int n;
{
	register u_char s = 0;

	while (n--)
		s += *p++;
	return (256 - s);
}

void
i_byte(i, p)
	int i;
	char *p;
{
	*(u_char *)p = i;
}

char *
o_byte(addr)
	char *addr;
{
	bufp=buffer;

	sprintf(buffer,"%s", addr);
	return(bufp);
}

void
i_banner(s, p)
	char *s, *p;
{

	strncpy(p, s, sizeof (eeprom.ee_diag.eed_banner));
}

char *
o_banner(addr)
	char *addr;
{

	return(o_string(addr, sizeof (eeprom.ee_diag.eed_banner)));
}

void
i_diagpath(s, p)
	char *s, *p;
{

	strncpy(p, s, sizeof (eeprom.ee_diag.eed_diagpath));
}

char *
o_diagpath(addr)
	char *addr;
{

	return(o_string(addr, sizeof (eeprom.ee_diag.eed_diagpath)));
}

char *
o_string(addr, len)
	char *addr;
	int len;
{
	bufp=buffer;

	sprintf(buffer,"%s", (addr[0] == '\377' ? "" : addr));
	return(bufp);
}

void
i_bool(i, p)
	int i;
	char *p;
{
	*(u_char *)p = i ? EE_TRUE : 0;
}

char *
o_bool(addr)
	char *addr;
{
	bufp=buffer;

	sprintf(buffer,"%s", *addr == EE_TRUE ? "1" : "0");
	return(bufp);
}

void
i_date(p)
	char *p;
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	*(u_int *)p = tv.tv_sec;
}

char *
o_date(addr)
	char *addr;
{
	bufp=buffer;

	sprintf(buffer,"%s", ctime((time_t *)addr));
	return(bufp);
}

void
i_bootdev(s, p)
	char *s, *p;
{
	char c1, c2;
	int ctlr, unit, part;

	if (sscanf(s, "%c%c(%x,%x,%x)", &c1, &c2, &ctlr, &unit, &part) != 5 &&
	    sscanf(s, "%c%c(0x%x,%x,%x)", &c1, &c2, &ctlr, &unit, &part) != 5) {
		fprintf(stderr, "eeprom: %s: bad boot device\n", s);
		return;
	}
	p[0] = c1;
	p[1] = c2;
	p[2] = ctlr;
	p[3] = unit;
	p[4] = part;
}

char *
o_bootdev(addr)
	char *addr;
{

	/*
	 * Note that we are passed the starting address here, and rely on
	 * knowledge of the adjacency of the fields.
	 */
	bufp=buffer;
	sprintf(buffer,"%c%c(%x,%x,%x)",
	    (addr[0] == '\377' ? '?' : addr[0]), 
	    (addr[1] == '\377' ? '?' : addr[1]), 
	    addr[2], addr[3], addr[4]);
	return(bufp);
}

void
i_console(i, p)
	int i;
	char *p;
{
	int val;

	if ( i == 0 )
		val = EED_CONS_BW;
	else if ( i == 1 )
		val = EED_CONS_TTYA;
	else if ( i == 2 )
		val = EED_CONS_TTYB;
	else if ( i == 3 )
		val = EED_CONS_COLOR;
	else if ( i == 4 )
		val = EED_CONS_P4;
	*(u_char *)p = val;
}

char *
o_console(addr)
	char *addr;
{
	char *val;
	bufp=buffer;

	switch (*addr) {
	case EED_CONS_BW:
	default:
		val = "0";
		break;
	case EED_CONS_TTYA:
		val = "1";
		break;
	case EED_CONS_TTYB:
		val = "2";
		break;
	case EED_CONS_COLOR:
		val = "3";
		break;
	case EED_CONS_P4:
		val = "4";
		break;
	}
	sprintf(buffer,"%s", val);
	return(bufp);
}

void
i_scrsize(i, p)
	int i;
	char *p;
{
	u_char val;

	if ( i == 0 )
		val = EED_SCR_1024X1024;
	else if ( i == 2 )
		val = EED_SCR_1600X1280;
	else if ( i == 3 )
		val = EED_SCR_1440X1440;
	else
		val = EED_SCR_1152X900;
	*(u_char *)p = val;
}

char *
o_scrsize(addr)
	char *addr;
{
	char *s;
	bufp=buffer;

	switch (*addr) {
	case EED_SCR_1024X1024:
		s = "0";
		break;
	case EED_SCR_1152X900:
	default:
		s = "1";
		break;
	case EED_SCR_1600X1280:
		s = "2";
		break;
	case EED_SCR_1440X1440:
		s = "3";
		break;
	}
	sprintf(buffer,"%s", s);
	return(bufp);
}

void
i_baud(s, p)
	char *s, *p;
{
	int val;

	(void) sscanf(s, "%d", &val);
	*((u_char *)p)++ = (val >> 8) & 0xff;
	*(u_char *)p = val & 0xff;
}

char *
o_baud(name, addr)
	char *name, *addr;
{
	int val = 0;
	bufp=buffer;

	val = *((u_char *)addr)++ << 8;
	val += *(u_char *)addr;
	sprintf(buffer,"%s", val);
	return(bufp);
}

read_eeprom()
{
	eeread(&eeprom);
}


write_eeprom()
{
	write_eestruct();	/* write the values to the eeprom structure */
	eewrite(&eeprom);
}

fix_chksum()
{
	eefix_chksum(&eeprom);
}
#endif	sun386

#ifdef sun4
/*
 * Checks if the cpuid matches that of sun4c series machines.
 * Returns 1 if its a sun4c,  0 otherwise.
 */
int
cpu_is_sun4c()
{
	unsigned machine_id;

	machine_id = sun_arch();
	if (machine_id == ARCH4C)	/* If it is a Sun4c */
	{
	  (void)confirm("The EEPROM feature is not available on Sun4c!", TRUE);
	  return(1);
	}
        if (machine_id == ARCH4M)   /* If it is a Sun4m */
        {
          (void)confirm("The EEPROM feature is not available on Sun4m!", TRUE);
          return(1);
        }
	return(0);
}
#endif