Annotation of sys/arch/mvme88k/dev/nvram.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: nvram.c,v 1.29 2006/06/19 15:13:35 deraadt Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1995 Theo de Raadt
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: *
! 15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
! 16: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 18: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
! 19: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 20: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 21: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 23: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 24: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 25: * SUCH DAMAGE.
! 26: */
! 27:
! 28: #include <sys/param.h>
! 29: #include <sys/kernel.h>
! 30: #include <sys/device.h>
! 31: #include <sys/malloc.h>
! 32: #include <sys/systm.h>
! 33: #include <sys/proc.h>
! 34: #include <sys/ioctl.h>
! 35: #include <sys/uio.h>
! 36:
! 37: #include <machine/autoconf.h>
! 38: #include <machine/bugio.h>
! 39: #include <machine/conf.h>
! 40: #include <machine/cpu.h>
! 41: #include <machine/mioctl.h>
! 42: #include <machine/psl.h>
! 43: #include <machine/vmparam.h>
! 44:
! 45: #include <uvm/uvm_param.h>
! 46:
! 47: #include <mvme88k/dev/memdevs.h>
! 48: #include <mvme88k/dev/nvramreg.h>
! 49: #include <mvme88k/dev/pcctworeg.h>
! 50:
! 51: struct nvramsoftc {
! 52: struct device sc_dev;
! 53: paddr_t sc_base;
! 54: bus_space_tag_t sc_iot;
! 55: bus_space_handle_t sc_ioh;
! 56: bus_addr_t sc_regs;
! 57: size_t sc_len;
! 58:
! 59: #ifdef MVME188
! 60: u_int8_t *sc_nvram;
! 61: #endif
! 62: };
! 63:
! 64: void nvramattach(struct device *, struct device *, void *);
! 65: int nvrammatch(struct device *, void *, void *);
! 66:
! 67: struct cfattach nvram_ca = {
! 68: sizeof(struct nvramsoftc), nvrammatch, nvramattach
! 69: };
! 70:
! 71: struct cfdriver nvram_cd = {
! 72: NULL, "nvram", DV_DULL
! 73: };
! 74:
! 75: u_long chiptotime(int, int, int, int, int, int);
! 76: int nvram188read(struct nvramsoftc *, struct uio *, int);
! 77: int nvram188write(struct nvramsoftc *, struct uio *, int);
! 78:
! 79: int
! 80: nvrammatch(parent, vcf, args)
! 81: struct device *parent;
! 82: void *vcf, *args;
! 83: {
! 84: struct confargs *ca = args;
! 85: bus_space_handle_t ioh;
! 86: int rc;
! 87:
! 88: if (bus_space_map(ca->ca_iot, ca->ca_paddr, PAGE_SIZE, 0, &ioh) != 0)
! 89: return (0);
! 90: rc = badaddr((vaddr_t)bus_space_vaddr(ca->ca_iot, ioh), 1) == 0;
! 91: bus_space_unmap(ca->ca_iot, ioh, PAGE_SIZE);
! 92: return (rc);
! 93: }
! 94:
! 95: void
! 96: nvramattach(parent, self, args)
! 97: struct device *parent, *self;
! 98: void *args;
! 99: {
! 100: struct confargs *ca = args;
! 101: struct nvramsoftc *sc = (struct nvramsoftc *)self;
! 102: bus_space_handle_t ioh;
! 103: vsize_t maplen;
! 104:
! 105: switch (brdtyp) {
! 106: #ifdef MVME188
! 107: case BRD_188:
! 108: sc->sc_len = MK48T02_SIZE;
! 109: maplen = sc->sc_len * 4;
! 110: sc->sc_regs = M188_NVRAM_TOD_OFF;
! 111: break;
! 112: #endif
! 113: default:
! 114: sc->sc_len = MK48T08_SIZE;
! 115: maplen = sc->sc_len;
! 116: sc->sc_regs = SBC_NVRAM_TOD_OFF;
! 117: break;
! 118: }
! 119:
! 120: sc->sc_iot = ca->ca_iot;
! 121: sc->sc_base = ca->ca_paddr;
! 122:
! 123: if (bus_space_map(sc->sc_iot, sc->sc_base, round_page(maplen),
! 124: BUS_SPACE_MAP_LINEAR, &ioh) != 0) {
! 125: printf(": can't map memory!\n");
! 126: return;
! 127: }
! 128:
! 129: sc->sc_ioh = ioh;
! 130:
! 131: printf(": MK48T0%d\n", sc->sc_len / 1024);
! 132: }
! 133:
! 134: /*
! 135: * Return the best possible estimate of the time in the timeval
! 136: * to which tvp points. We do this by returning the current time
! 137: * plus the amount of time since the last clock interrupt (clock.c:clkread).
! 138: *
! 139: * Check that this time is no less than any previously-reported time,
! 140: * which could happen around the time of a clock adjustment. Just for fun,
! 141: * we guarantee that the time will be greater than the value obtained by a
! 142: * previous call.
! 143: */
! 144: void
! 145: microtime(tvp)
! 146: struct timeval *tvp;
! 147: {
! 148: int s = splhigh();
! 149: static struct timeval lasttime;
! 150:
! 151: *tvp = time;
! 152: while (tvp->tv_usec >= 1000000) {
! 153: tvp->tv_sec++;
! 154: tvp->tv_usec -= 1000000;
! 155: }
! 156: if (tvp->tv_sec == lasttime.tv_sec &&
! 157: tvp->tv_usec <= lasttime.tv_usec &&
! 158: (tvp->tv_usec = lasttime.tv_usec + 1) >= 1000000) {
! 159: tvp->tv_sec++;
! 160: tvp->tv_usec -= 1000000;
! 161: }
! 162: lasttime = *tvp;
! 163: splx(s);
! 164: }
! 165:
! 166: /*
! 167: * BCD to decimal and decimal to BCD.
! 168: */
! 169: #define FROMBCD(x) (((x) >> 4) * 10 + ((x) & 0xf))
! 170: #define TOBCD(x) (((x) / 10 * 16) + ((x) % 10))
! 171:
! 172: #define SECYR (SECDAY * 365)
! 173: #define LEAPYEAR(y) (((y) & 3) == 0)
! 174:
! 175: /*
! 176: * This code is defunct after 2068.
! 177: * Will Unix still be here then??
! 178: */
! 179: const int dayyr[12] =
! 180: { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
! 181:
! 182: u_long
! 183: chiptotime(sec, min, hour, day, mon, year)
! 184: int sec, min, hour, day, mon, year;
! 185: {
! 186: int days, yr;
! 187:
! 188: sec = FROMBCD(sec);
! 189: min = FROMBCD(min);
! 190: hour = FROMBCD(hour);
! 191: day = FROMBCD(day);
! 192: mon = FROMBCD(mon);
! 193: year = FROMBCD(year) + YEAR0;
! 194:
! 195: /* simple sanity checks */
! 196: if (year>164 || mon<1 || mon>12 || day<1 || day>31)
! 197: return (0);
! 198: yr = 70;
! 199: days = 0;
! 200:
! 201: if (year < 70) { /* 2000 <= year */
! 202: for (; yr < 100; yr++) /* deal with first 30 years */
! 203: days += LEAPYEAR(yr) ? 366 : 365;
! 204: yr = 0;
! 205: }
! 206:
! 207: for (; yr < year; yr++) /* deal with years left */
! 208: days += LEAPYEAR(yr) ? 366 : 365;
! 209:
! 210: days += dayyr[mon - 1] + day - 1;
! 211:
! 212: if (LEAPYEAR(yr) && mon > 2)
! 213: days++;
! 214:
! 215: /* now have days since Jan 1, 1970; the rest is easy... */
! 216: return (days * SECDAY + hour * 3600 + min * 60 + sec);
! 217: }
! 218:
! 219: struct chiptime {
! 220: int sec;
! 221: int min;
! 222: int hour;
! 223: int wday;
! 224: int day;
! 225: int mon;
! 226: int year;
! 227: };
! 228:
! 229: void timetochip(struct chiptime *c);
! 230:
! 231: void
! 232: timetochip(c)
! 233: struct chiptime *c;
! 234: {
! 235: int t, t2, t3, now = time.tv_sec;
! 236:
! 237: /* January 1 1970 was a Thursday (4 in unix wdays) */
! 238: /* compute the days since the epoch */
! 239: t2 = now / SECDAY;
! 240:
! 241: t3 = (t2 + 4) % 7; /* day of week */
! 242: c->wday = TOBCD(t3 + 1);
! 243:
! 244: /* compute the year */
! 245: t = 69;
! 246: while (t2 >= 0) { /* whittle off years */
! 247: t3 = t2;
! 248: t++;
! 249: t2 -= LEAPYEAR(t) ? 366 : 365;
! 250: }
! 251: c->year = t;
! 252:
! 253: /* t3 = month + day; separate */
! 254: t = LEAPYEAR(t);
! 255: for (t2 = 1; t2 < 12; t2++)
! 256: if (t3 < (dayyr[t2] + ((t && (t2 > 1)) ? 1:0)))
! 257: break;
! 258:
! 259: /* t2 is month */
! 260: c->mon = t2;
! 261: c->day = t3 - dayyr[t2 - 1] + 1;
! 262: if (t && t2 > 2)
! 263: c->day--;
! 264:
! 265: /* the rest is easy */
! 266: t = now % SECDAY;
! 267: c->hour = t / 3600;
! 268: t %= 3600;
! 269: c->min = t / 60;
! 270: c->sec = t % 60;
! 271:
! 272: c->sec = TOBCD(c->sec);
! 273: c->min = TOBCD(c->min);
! 274: c->hour = TOBCD(c->hour);
! 275: c->day = TOBCD(c->day);
! 276: c->mon = TOBCD(c->mon);
! 277: c->year = TOBCD((c->year - YEAR0) % 100);
! 278: }
! 279:
! 280: /*
! 281: * Set up the system's time, given a `reasonable' time value.
! 282: */
! 283:
! 284: void
! 285: inittodr(base)
! 286: time_t base;
! 287: {
! 288: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[0];
! 289: int sec, min, hour, day, mon, year;
! 290: int badbase = 0, waszero = base == 0;
! 291:
! 292: if (base < 35 * SECYR) {
! 293: /*
! 294: * If base is 0, assume filesystem time is just unknown
! 295: * in stead of preposterous. Don't bark.
! 296: */
! 297: if (base != 0)
! 298: printf("WARNING: preposterous time in file system\n");
! 299: /* not going to use it anyway, if the chip is readable */
! 300: base = 36 * SECYR + 109 * SECDAY + 22 * 3600;
! 301: badbase = 1;
! 302: }
! 303:
! 304: if (brdtyp == BRD_188) {
! 305: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 306: sc->sc_regs + (CLK_CSR << 2), CLK_READ |
! 307: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 308: sc->sc_regs + (CLK_CSR << 2)));
! 309: sec = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 310: sc->sc_regs + (CLK_SEC << 2)) & 0xff;
! 311: min = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 312: sc->sc_regs + (CLK_MIN << 2)) & 0xff;
! 313: hour = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 314: sc->sc_regs + (CLK_HOUR << 2)) & 0xff;
! 315: day = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 316: sc->sc_regs + (CLK_DAY << 2)) & 0xff;
! 317: mon = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 318: sc->sc_regs + (CLK_MONTH << 2)) & 0xff;
! 319: year = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 320: sc->sc_regs + (CLK_YEAR << 2)) & 0xff;
! 321: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 322: sc->sc_regs + (CLK_CSR << 2),
! 323: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 324: sc->sc_regs + (CLK_CSR << 2)) & ~CLK_READ);
! 325: } else {
! 326: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 327: sc->sc_regs + CLK_CSR, CLK_READ |
! 328: bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 329: sc->sc_regs + CLK_CSR));
! 330: sec = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 331: sc->sc_regs + CLK_SEC);
! 332: min = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 333: sc->sc_regs + CLK_MIN);
! 334: hour = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 335: sc->sc_regs + CLK_HOUR);
! 336: day = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 337: sc->sc_regs + CLK_DAY);
! 338: mon = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 339: sc->sc_regs + CLK_MONTH);
! 340: year = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 341: sc->sc_regs + CLK_YEAR);
! 342: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 343: sc->sc_regs + CLK_CSR,
! 344: bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 345: sc->sc_regs + CLK_CSR) & ~CLK_READ);
! 346: }
! 347:
! 348: if ((time.tv_sec = chiptotime(sec, min, hour, day, mon, year)) == 0) {
! 349: printf("WARNING: bad date in nvram");
! 350: #ifdef DEBUG
! 351: printf("\nday = %d, mon = %d, year = %d, hour = %d, min = %d, sec = %d",
! 352: FROMBCD(day), FROMBCD(mon), FROMBCD(year) + YEAR0,
! 353: FROMBCD(hour), FROMBCD(min), FROMBCD(sec));
! 354: #endif
! 355: /*
! 356: * Believe the time in the file system for lack of
! 357: * anything better, resetting the clock.
! 358: */
! 359: time.tv_sec = base;
! 360: if (!badbase)
! 361: resettodr();
! 362: } else {
! 363: int deltat = time.tv_sec - base;
! 364:
! 365: if (deltat < 0)
! 366: deltat = -deltat;
! 367: if (waszero || deltat < 2 * SECDAY)
! 368: return;
! 369: printf("WARNING: clock %s %d days",
! 370: time.tv_sec < base ? "lost" : "gained", deltat / SECDAY);
! 371: }
! 372: printf(" -- CHECK AND RESET THE DATE!\n");
! 373: }
! 374:
! 375: /*
! 376: * Reset the clock based on the current time.
! 377: * Used when the current clock is preposterous, when the time is changed,
! 378: * and when rebooting. Do nothing if the time is not yet known, e.g.,
! 379: * when crashing during autoconfig.
! 380: */
! 381: void
! 382: resettodr()
! 383: {
! 384: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[0];
! 385: struct chiptime c;
! 386:
! 387: if (!time.tv_sec || sc == NULL)
! 388: return;
! 389: timetochip(&c);
! 390:
! 391: if (brdtyp == BRD_188) {
! 392: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 393: sc->sc_regs + (CLK_CSR << 2), CLK_WRITE |
! 394: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 395: sc->sc_regs + (CLK_CSR << 2)));
! 396: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 397: sc->sc_regs + (CLK_SEC << 2), c.sec);
! 398: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 399: sc->sc_regs + (CLK_MIN << 2), c.min);
! 400: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 401: sc->sc_regs + (CLK_HOUR << 2), c.hour);
! 402: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 403: sc->sc_regs + (CLK_WDAY << 2), c.wday);
! 404: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 405: sc->sc_regs + (CLK_DAY << 2), c.day);
! 406: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 407: sc->sc_regs + (CLK_MONTH << 2), c.mon);
! 408: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 409: sc->sc_regs + (CLK_YEAR << 2), c.year);
! 410: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 411: sc->sc_regs + (CLK_CSR << 2),
! 412: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 413: sc->sc_regs + (CLK_CSR << 2)) & ~CLK_WRITE);
! 414: } else {
! 415: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 416: sc->sc_regs + CLK_CSR, CLK_WRITE |
! 417: bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 418: sc->sc_regs + CLK_CSR));
! 419: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 420: sc->sc_regs + CLK_SEC, c.sec);
! 421: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 422: sc->sc_regs + CLK_MIN, c.min);
! 423: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 424: sc->sc_regs + CLK_HOUR, c.hour);
! 425: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 426: sc->sc_regs + CLK_WDAY, c.wday);
! 427: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 428: sc->sc_regs + CLK_DAY, c.day);
! 429: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 430: sc->sc_regs + CLK_MONTH, c.mon);
! 431: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 432: sc->sc_regs + CLK_YEAR, c.year);
! 433: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
! 434: sc->sc_regs + CLK_CSR,
! 435: bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 436: sc->sc_regs + CLK_CSR) & ~CLK_WRITE);
! 437: }
! 438: }
! 439:
! 440: /*ARGSUSED*/
! 441: int
! 442: nvramopen(dev, flag, mode, p)
! 443: dev_t dev;
! 444: int flag, mode;
! 445: struct proc *p;
! 446: {
! 447: if (minor(dev) >= nvram_cd.cd_ndevs ||
! 448: nvram_cd.cd_devs[minor(dev)] == NULL)
! 449: return (ENODEV);
! 450:
! 451: return (0);
! 452: }
! 453:
! 454: /*ARGSUSED*/
! 455: int
! 456: nvramclose(dev, flag, mode, p)
! 457: dev_t dev;
! 458: int flag, mode;
! 459: struct proc *p;
! 460: {
! 461: /*
! 462: * On MVME188, it might be worth free()ing the NVRAM copy here.
! 463: */
! 464: return (0);
! 465: }
! 466:
! 467: /*ARGSUSED*/
! 468: int
! 469: nvramioctl(dev, cmd, data, flag, p)
! 470: dev_t dev;
! 471: u_long cmd;
! 472: caddr_t data;
! 473: int flag;
! 474: struct proc *p;
! 475: {
! 476: int unit = minor(dev);
! 477: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
! 478: int error = 0;
! 479:
! 480: switch (cmd) {
! 481: case MIOCGSIZ:
! 482: *(int *)data = sc->sc_len;
! 483: break;
! 484: default:
! 485: error = ENOTTY;
! 486: break;
! 487: }
! 488: return (error);
! 489: }
! 490:
! 491: /*ARGSUSED*/
! 492: int
! 493: nvramread(dev_t dev, struct uio *uio, int flags)
! 494: {
! 495: int unit = minor(dev);
! 496: struct nvramsoftc *sc = (struct nvramsoftc *)nvram_cd.cd_devs[unit];
! 497:
! 498: #ifdef MVME188
! 499: if (brdtyp == BRD_188)
! 500: return (nvram188read(sc, uio, flags));
! 501: #endif
! 502:
! 503: return (memdevrw(bus_space_vaddr(sc->sc_iot, sc->sc_ioh),
! 504: sc->sc_len, uio, flags));
! 505: }
! 506:
! 507: /*ARGSUSED*/
! 508: int
! 509: nvramwrite(dev_t dev, struct uio *uio, int flags)
! 510: {
! 511: int unit = minor(dev);
! 512: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
! 513:
! 514: #ifdef MVME188
! 515: if (brdtyp == BRD_188)
! 516: return (nvram188write(sc, uio, flags));
! 517: #endif
! 518:
! 519: return (memdevrw(bus_space_vaddr(sc->sc_iot, sc->sc_ioh),
! 520: sc->sc_len, uio, flags));
! 521: }
! 522:
! 523: paddr_t
! 524: nvrammmap(dev, off, prot)
! 525: dev_t dev;
! 526: off_t off;
! 527: int prot;
! 528: {
! 529: int unit = minor(dev);
! 530: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
! 531:
! 532: if (minor(dev) != 0)
! 533: return (-1);
! 534:
! 535: #ifdef MVME188
! 536: /* disallow mmap on MVME188 due to non-linear layout */
! 537: if (brdtyp == BRD_188)
! 538: return (-1);
! 539: #endif
! 540:
! 541: /* allow access only in RAM */
! 542: if (off < 0 || off > sc->sc_len)
! 543: return (-1);
! 544: return (atop(sc->sc_base + off));
! 545: }
! 546:
! 547: #ifdef MVME188
! 548:
! 549: int read_nvram(struct nvramsoftc *);
! 550:
! 551: /*
! 552: * Build a local copy of the NVRAM contents.
! 553: */
! 554: int
! 555: read_nvram(struct nvramsoftc *sc)
! 556: {
! 557: u_int cnt;
! 558: u_int8_t *dest;
! 559: u_int32_t *src;
! 560:
! 561: if (sc->sc_nvram == NULL) {
! 562: sc->sc_nvram = (u_int8_t *)malloc(sc->sc_len, M_DEVBUF,
! 563: M_WAITOK | M_CANFAIL);
! 564: if (sc->sc_nvram == NULL)
! 565: return (EAGAIN);
! 566: }
! 567:
! 568: dest = sc->sc_nvram;
! 569: src = (u_int32_t *)bus_space_vaddr(sc->sc_iot, sc->sc_ioh);
! 570: cnt = sc->sc_len;
! 571: while (cnt-- != 0)
! 572: *dest++ = (u_int8_t)*src++;
! 573:
! 574: return (0);
! 575: }
! 576:
! 577: /*
! 578: * Specific memdevrw wrappers to cope with the 188 design.
! 579: */
! 580:
! 581: int
! 582: nvram188read(struct nvramsoftc *sc, struct uio *uio, int flags)
! 583: {
! 584: int rc;
! 585:
! 586: /*
! 587: * Get a copy of the NVRAM contents.
! 588: */
! 589: rc = read_nvram(sc);
! 590: if (rc != 0)
! 591: return (rc);
! 592:
! 593: /*
! 594: * Move data from our NVRAM copy to the user.
! 595: */
! 596: return (memdevrw(sc->sc_nvram, sc->sc_len, uio, flags));
! 597: }
! 598:
! 599: int
! 600: nvram188write(struct nvramsoftc *sc, struct uio *uio, int flags)
! 601: {
! 602: u_int cnt;
! 603: u_int8_t *src;
! 604: u_int32_t *dest;
! 605: int rc;
! 606:
! 607: /*
! 608: * Get a copy of the NVRAM contents.
! 609: */
! 610: rc = read_nvram(sc);
! 611: if (rc != 0)
! 612: return (rc);
! 613:
! 614: /*
! 615: * Move data from the user to our NVRAM copy.
! 616: */
! 617: rc = memdevrw(sc->sc_nvram, sc->sc_len, uio, flags);
! 618: if (rc != 0) {
! 619: /* reset NVRAM copy contents */
! 620: read_nvram(sc);
! 621: return (rc);
! 622: }
! 623:
! 624: /*
! 625: * Update the NVRAM. This could be optimized by only working on
! 626: * the areas which have been modified by the user.
! 627: */
! 628: src = sc->sc_nvram;
! 629: dest = (u_int32_t *)bus_space_vaddr(sc->sc_iot, sc->sc_ioh);
! 630: cnt = sc->sc_len;
! 631: while (cnt-- != 0) {
! 632: if ((*dest & 0xff) != *src)
! 633: *dest = (u_int32_t)*src;
! 634: dest++;
! 635: src++;
! 636: }
! 637:
! 638: return (0);
! 639: }
! 640: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to nvram.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvme88k / dev