Annotation of sys/arch/aviion/dev/nvram.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: nvram.c,v 1.4 2006/07/17 04:21:30 miod 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/conf.h>
! 39: #include <machine/cpu.h>
! 40: #include <machine/mioctl.h>
! 41: #include <machine/psl.h>
! 42: #include <machine/vmparam.h>
! 43:
! 44: #include <uvm/uvm_param.h>
! 45:
! 46: #include <aviion/dev/nvramreg.h>
! 47:
! 48: struct nvramsoftc {
! 49: struct device sc_dev;
! 50: paddr_t sc_base;
! 51: bus_space_tag_t sc_iot;
! 52: bus_space_handle_t sc_ioh;
! 53: bus_addr_t sc_regs;
! 54: size_t sc_len;
! 55: u_int8_t *sc_nvram;
! 56: };
! 57:
! 58: void nvramattach(struct device *, struct device *, void *);
! 59: int nvrammatch(struct device *, void *, void *);
! 60:
! 61: struct cfattach nvram_ca = {
! 62: sizeof(struct nvramsoftc), nvrammatch, nvramattach
! 63: };
! 64:
! 65: struct cfdriver nvram_cd = {
! 66: NULL, "nvram", DV_DULL
! 67: };
! 68:
! 69: u_long chiptotime(int, int, int, int, int, int);
! 70: int nvramrw(caddr_t, int, struct uio *, int);
! 71:
! 72: int
! 73: nvrammatch(parent, vcf, args)
! 74: struct device *parent;
! 75: void *vcf, *args;
! 76: {
! 77: struct confargs *ca = args;
! 78: bus_space_handle_t ioh;
! 79: int rc;
! 80:
! 81: if (bus_space_map(ca->ca_iot, ca->ca_paddr, PAGE_SIZE, 0, &ioh) != 0)
! 82: return (0);
! 83: rc = badaddr((vaddr_t)bus_space_vaddr(ca->ca_iot, ioh), 1) == 0;
! 84: bus_space_unmap(ca->ca_iot, ioh, PAGE_SIZE);
! 85: return (rc);
! 86: }
! 87:
! 88: void
! 89: nvramattach(parent, self, args)
! 90: struct device *parent, *self;
! 91: void *args;
! 92: {
! 93: struct confargs *ca = args;
! 94: struct nvramsoftc *sc = (struct nvramsoftc *)self;
! 95: bus_space_handle_t ioh;
! 96: vsize_t maplen;
! 97:
! 98: sc->sc_len = MK48T02_SIZE;
! 99: sc->sc_regs = AV_NVRAM_TOD_OFF;
! 100:
! 101: sc->sc_iot = ca->ca_iot;
! 102: sc->sc_base = ca->ca_paddr;
! 103:
! 104: /*
! 105: * The NK48T02 is mapped as one byte per longword,
! 106: * thus spans four times as much address space.
! 107: */
! 108: maplen = sc->sc_len * 4;
! 109:
! 110: if (bus_space_map(sc->sc_iot, sc->sc_base, round_page(maplen),
! 111: BUS_SPACE_MAP_LINEAR, &ioh) != 0) {
! 112: printf(": can't map memory!\n");
! 113: return;
! 114: }
! 115:
! 116: sc->sc_ioh = ioh;
! 117:
! 118: printf(": MK48T0%d\n", sc->sc_len / 1024);
! 119: }
! 120:
! 121: /*
! 122: * Return the best possible estimate of the time in the timeval
! 123: * to which tvp points. We do this by returning the current time
! 124: * plus the amount of time since the last clock interrupt (clock.c:clkread).
! 125: *
! 126: * Check that this time is no less than any previously-reported time,
! 127: * which could happen around the time of a clock adjustment. Just for fun,
! 128: * we guarantee that the time will be greater than the value obtained by a
! 129: * previous call.
! 130: */
! 131: void
! 132: microtime(tvp)
! 133: struct timeval *tvp;
! 134: {
! 135: int s = splhigh();
! 136: static struct timeval lasttime;
! 137:
! 138: *tvp = time;
! 139: while (tvp->tv_usec >= 1000000) {
! 140: tvp->tv_sec++;
! 141: tvp->tv_usec -= 1000000;
! 142: }
! 143: if (tvp->tv_sec == lasttime.tv_sec &&
! 144: tvp->tv_usec <= lasttime.tv_usec &&
! 145: (tvp->tv_usec = lasttime.tv_usec + 1) >= 1000000) {
! 146: tvp->tv_sec++;
! 147: tvp->tv_usec -= 1000000;
! 148: }
! 149: lasttime = *tvp;
! 150: splx(s);
! 151: }
! 152:
! 153: #define LEAPYEAR(y) (((y) & 3) == 0)
! 154:
! 155: /*
! 156: * This code is defunct after 2068.
! 157: * Will Unix still be here then??
! 158: */
! 159: const int dayyr[12] =
! 160: { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
! 161:
! 162: u_long
! 163: chiptotime(sec, min, hour, day, mon, year)
! 164: int sec, min, hour, day, mon, year;
! 165: {
! 166: int days, yr;
! 167:
! 168: sec = FROMBCD(sec);
! 169: min = FROMBCD(min);
! 170: hour = FROMBCD(hour);
! 171: day = FROMBCD(day);
! 172: mon = FROMBCD(mon);
! 173: year = FROMBCD(year) + YEAR0;
! 174:
! 175: /* simple sanity checks */
! 176: if (year>164 || mon<1 || mon>12 || day<1 || day>31)
! 177: return (0);
! 178: yr = 70;
! 179: days = 0;
! 180:
! 181: if (year < 70) { /* 2000 <= year */
! 182: for (; yr < 100; yr++) /* deal with first 30 years */
! 183: days += LEAPYEAR(yr) ? 366 : 365;
! 184: yr = 0;
! 185: }
! 186:
! 187: for (; yr < year; yr++) /* deal with years left */
! 188: days += LEAPYEAR(yr) ? 366 : 365;
! 189:
! 190: days += dayyr[mon - 1] + day - 1;
! 191:
! 192: if (LEAPYEAR(yr) && mon > 2)
! 193: days++;
! 194:
! 195: /* now have days since Jan 1, 1970; the rest is easy... */
! 196: return (days * SECDAY + hour * 3600 + min * 60 + sec);
! 197: }
! 198:
! 199: struct chiptime {
! 200: int sec;
! 201: int min;
! 202: int hour;
! 203: int wday;
! 204: int day;
! 205: int mon;
! 206: int year;
! 207: };
! 208:
! 209: void timetochip(struct chiptime *c);
! 210:
! 211: void
! 212: timetochip(c)
! 213: struct chiptime *c;
! 214: {
! 215: int t, t2, t3, now = time.tv_sec;
! 216:
! 217: /* January 1 1970 was a Thursday (4 in unix wdays) */
! 218: /* compute the days since the epoch */
! 219: t2 = now / SECDAY;
! 220:
! 221: t3 = (t2 + 4) % 7; /* day of week */
! 222: c->wday = TOBCD(t3 + 1);
! 223:
! 224: /* compute the year */
! 225: t = 69;
! 226: while (t2 >= 0) { /* whittle off years */
! 227: t3 = t2;
! 228: t++;
! 229: t2 -= LEAPYEAR(t) ? 366 : 365;
! 230: }
! 231: c->year = t;
! 232:
! 233: /* t3 = month + day; separate */
! 234: t = LEAPYEAR(t);
! 235: for (t2 = 1; t2 < 12; t2++)
! 236: if (t3 < (dayyr[t2] + ((t && (t2 > 1)) ? 1:0)))
! 237: break;
! 238:
! 239: /* t2 is month */
! 240: c->mon = t2;
! 241: c->day = t3 - dayyr[t2 - 1] + 1;
! 242: if (t && t2 > 2)
! 243: c->day--;
! 244:
! 245: /* the rest is easy */
! 246: t = now % SECDAY;
! 247: c->hour = t / 3600;
! 248: t %= 3600;
! 249: c->min = t / 60;
! 250: c->sec = t % 60;
! 251:
! 252: c->sec = TOBCD(c->sec);
! 253: c->min = TOBCD(c->min);
! 254: c->hour = TOBCD(c->hour);
! 255: c->day = TOBCD(c->day);
! 256: c->mon = TOBCD(c->mon);
! 257: c->year = TOBCD((c->year - YEAR0) % 100);
! 258: }
! 259:
! 260: /*
! 261: * Set up the system's time, given a `reasonable' time value.
! 262: */
! 263:
! 264: void
! 265: inittodr(base)
! 266: time_t base;
! 267: {
! 268: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[0];
! 269: int sec, min, hour, day, mon, year;
! 270: int badbase = 0, waszero = base == 0;
! 271:
! 272: if (base < 36 * SECYR) { /* this code did not exist until 2006 */
! 273: /*
! 274: * If base is 0, assume filesystem time is just unknown
! 275: * in stead of preposterous. Don't bark.
! 276: */
! 277: if (base != 0)
! 278: printf("WARNING: preposterous time in file system\n");
! 279: /* not going to use it anyway, if the chip is readable */
! 280: base = 36 * SECYR + 109 * SECDAY + 22 * 3600;
! 281: badbase = 1;
! 282: }
! 283:
! 284: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 285: sc->sc_regs + (CLK_CSR << 2), CLK_READ |
! 286: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 287: sc->sc_regs + (CLK_CSR << 2)));
! 288: sec = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 289: sc->sc_regs + (CLK_SEC << 2)) & 0xff;
! 290: min = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 291: sc->sc_regs + (CLK_MIN << 2)) & 0xff;
! 292: hour = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 293: sc->sc_regs + (CLK_HOUR << 2)) & 0xff;
! 294: day = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 295: sc->sc_regs + (CLK_DAY << 2)) & 0xff;
! 296: mon = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 297: sc->sc_regs + (CLK_MONTH << 2)) & 0xff;
! 298: year = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 299: sc->sc_regs + (CLK_YEAR << 2)) & 0xff;
! 300: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 301: sc->sc_regs + (CLK_CSR << 2),
! 302: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 303: sc->sc_regs + (CLK_CSR << 2)) & ~CLK_READ);
! 304:
! 305: if ((time.tv_sec = chiptotime(sec, min, hour, day, mon, year)) == 0) {
! 306: printf("WARNING: bad date in nvram");
! 307: #ifdef DEBUG
! 308: printf("\nday = %d, mon = %d, year = %d, hour = %d, min = %d, sec = %d",
! 309: FROMBCD(day), FROMBCD(mon), FROMBCD(year) + YEAR0,
! 310: FROMBCD(hour), FROMBCD(min), FROMBCD(sec));
! 311: #endif
! 312: /*
! 313: * Believe the time in the file system for lack of
! 314: * anything better, resetting the clock.
! 315: */
! 316: time.tv_sec = base;
! 317: if (!badbase)
! 318: resettodr();
! 319: } else {
! 320: int deltat = time.tv_sec - base;
! 321:
! 322: if (deltat < 0)
! 323: deltat = -deltat;
! 324: if (waszero || deltat < 2 * SECDAY)
! 325: return;
! 326: printf("WARNING: clock %s %d days",
! 327: time.tv_sec < base ? "lost" : "gained", deltat / SECDAY);
! 328: }
! 329: printf(" -- CHECK AND RESET THE DATE!\n");
! 330: }
! 331:
! 332: /*
! 333: * Reset the clock based on the current time.
! 334: * Used when the current clock is preposterous, when the time is changed,
! 335: * and when rebooting. Do nothing if the time is not yet known, e.g.,
! 336: * when crashing during autoconfig.
! 337: */
! 338: void
! 339: resettodr()
! 340: {
! 341: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[0];
! 342: struct chiptime c;
! 343:
! 344: if (!time.tv_sec || sc == NULL)
! 345: return;
! 346: timetochip(&c);
! 347:
! 348: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 349: sc->sc_regs + (CLK_CSR << 2), CLK_WRITE |
! 350: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 351: sc->sc_regs + (CLK_CSR << 2)));
! 352: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 353: sc->sc_regs + (CLK_SEC << 2), c.sec);
! 354: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 355: sc->sc_regs + (CLK_MIN << 2), c.min);
! 356: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 357: sc->sc_regs + (CLK_HOUR << 2), c.hour);
! 358: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 359: sc->sc_regs + (CLK_WDAY << 2), c.wday);
! 360: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 361: sc->sc_regs + (CLK_DAY << 2), c.day);
! 362: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 363: sc->sc_regs + (CLK_MONTH << 2), c.mon);
! 364: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 365: sc->sc_regs + (CLK_YEAR << 2), c.year);
! 366: bus_space_write_4(sc->sc_iot, sc->sc_ioh,
! 367: sc->sc_regs + (CLK_CSR << 2),
! 368: bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 369: sc->sc_regs + (CLK_CSR << 2)) & ~CLK_WRITE);
! 370: }
! 371:
! 372: /*ARGSUSED*/
! 373: int
! 374: nvramopen(dev, flag, mode, p)
! 375: dev_t dev;
! 376: int flag, mode;
! 377: struct proc *p;
! 378: {
! 379: if (minor(dev) >= nvram_cd.cd_ndevs ||
! 380: nvram_cd.cd_devs[minor(dev)] == NULL)
! 381: return (ENODEV);
! 382:
! 383: return (0);
! 384: }
! 385:
! 386: /*ARGSUSED*/
! 387: int
! 388: nvramclose(dev, flag, mode, p)
! 389: dev_t dev;
! 390: int flag, mode;
! 391: struct proc *p;
! 392: {
! 393: /*
! 394: * It might be worth free()ing the NVRAM copy here.
! 395: */
! 396: return (0);
! 397: }
! 398:
! 399: /*ARGSUSED*/
! 400: int
! 401: nvramioctl(dev, cmd, data, flag, p)
! 402: dev_t dev;
! 403: u_long cmd;
! 404: caddr_t data;
! 405: int flag;
! 406: struct proc *p;
! 407: {
! 408: int unit = minor(dev);
! 409: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
! 410: int error = 0;
! 411:
! 412: switch (cmd) {
! 413: case MIOCGSIZ:
! 414: *(int *)data = sc->sc_len;
! 415: break;
! 416: default:
! 417: error = ENOTTY;
! 418: break;
! 419: }
! 420: return (error);
! 421: }
! 422:
! 423: paddr_t
! 424: nvrammmap(dev, off, prot)
! 425: dev_t dev;
! 426: off_t off;
! 427: int prot;
! 428: {
! 429: #if 0
! 430: int unit = minor(dev);
! 431: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
! 432:
! 433: if (minor(dev) != 0)
! 434: return (-1);
! 435:
! 436: /* allow access only in RAM */
! 437: if (off < 0 || off > sc->sc_len)
! 438: return (-1);
! 439: return (atop(sc->sc_base + off));
! 440: #else
! 441: /* disallow mmap due to non-linear layout */
! 442: return (-1);
! 443: #endif
! 444: }
! 445:
! 446: int read_nvram(struct nvramsoftc *);
! 447:
! 448: /*
! 449: * Build a local copy of the NVRAM contents.
! 450: */
! 451: int
! 452: read_nvram(struct nvramsoftc *sc)
! 453: {
! 454: u_int cnt;
! 455: u_int8_t *dest;
! 456: u_int32_t *src;
! 457:
! 458: if (sc->sc_nvram == NULL) {
! 459: sc->sc_nvram = (u_int8_t *)malloc(sc->sc_len, M_DEVBUF,
! 460: M_WAITOK | M_CANFAIL);
! 461: if (sc->sc_nvram == NULL)
! 462: return (EAGAIN);
! 463: }
! 464:
! 465: dest = sc->sc_nvram;
! 466: src = (u_int32_t *)bus_space_vaddr(sc->sc_iot, sc->sc_ioh);
! 467: cnt = sc->sc_len;
! 468: while (cnt-- != 0)
! 469: *dest++ = (u_int8_t)*src++;
! 470:
! 471: return (0);
! 472: }
! 473:
! 474: /*ARGSUSED*/
! 475: int
! 476: nvramrw(caddr_t base, int len, struct uio *uio, int flags)
! 477: {
! 478: vaddr_t v;
! 479: int c;
! 480: struct iovec *iov;
! 481: int error = 0;
! 482:
! 483: while (uio->uio_resid > 0 && error == 0) {
! 484: iov = uio->uio_iov;
! 485: if (iov->iov_len == 0) {
! 486: uio->uio_iov++;
! 487: uio->uio_iovcnt--;
! 488: #ifdef DIAGNOSTIC
! 489: if (uio->uio_iovcnt < 0)
! 490: panic("nvramrw");
! 491: #endif
! 492: continue;
! 493: }
! 494:
! 495: v = uio->uio_offset;
! 496: c = min(iov->iov_len, MAXPHYS);
! 497: if (v + c > len)
! 498: c = len - v; /* till end of dev */
! 499: if (c == 0)
! 500: return (0);
! 501: error = uiomove(base + v, c, uio);
! 502: }
! 503: return (error);
! 504: }
! 505:
! 506: int
! 507: nvramread(dev_t dev, struct uio *uio, int flags)
! 508: {
! 509: int unit = minor(dev);
! 510: struct nvramsoftc *sc = (struct nvramsoftc *)nvram_cd.cd_devs[unit];
! 511: int rc;
! 512:
! 513: /*
! 514: * Get a copy of the NVRAM contents.
! 515: */
! 516: rc = read_nvram(sc);
! 517: if (rc != 0)
! 518: return (rc);
! 519:
! 520: /*
! 521: * Move data from our NVRAM copy to the user.
! 522: */
! 523: return (nvramrw(sc->sc_nvram, sc->sc_len, uio, flags));
! 524: }
! 525:
! 526: int
! 527: nvramwrite(dev_t dev, struct uio *uio, int flags)
! 528: {
! 529: int unit = minor(dev);
! 530: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
! 531: u_int cnt;
! 532: u_int8_t *src;
! 533: u_int32_t *dest;
! 534: int rc;
! 535:
! 536: /*
! 537: * Get a copy of the NVRAM contents.
! 538: */
! 539: rc = read_nvram(sc);
! 540: if (rc != 0)
! 541: return (rc);
! 542:
! 543: /*
! 544: * Move data from the user to our NVRAM copy.
! 545: */
! 546: rc = nvramrw(sc->sc_nvram, sc->sc_len, uio, flags);
! 547: if (rc != 0) {
! 548: /* reset NVRAM copy contents */
! 549: read_nvram(sc);
! 550: return (rc);
! 551: }
! 552:
! 553: /*
! 554: * Update the NVRAM. This could be optimized by only working on
! 555: * the areas which have been modified by the user.
! 556: */
! 557: src = sc->sc_nvram;
! 558: dest = (u_int32_t *)bus_space_vaddr(sc->sc_iot, sc->sc_ioh);
! 559: cnt = sc->sc_len;
! 560: while (cnt-- != 0) {
! 561: if ((*dest & 0xff) != *src) {
! 562: *dest = (u_int32_t)*src;
! 563: /*
! 564: * A jumper on the motherboard may write-protect
! 565: * the 0x80 bytes at offset 0x80 (i.e. addresses
! 566: * 0x200-0x3ff), so check our write had successed.
! 567: * If it failed, discard the remainder of the changes
! 568: * and return EROFS.
! 569: */
! 570: if ((*dest & 0xff) != *src)
! 571: rc = EROFS;
! 572: }
! 573: dest++;
! 574: src++;
! 575: }
! 576:
! 577: if (rc != 0) {
! 578: /* reset NVRAM copy contents */
! 579: read_nvram(sc);
! 580: }
! 581:
! 582: return (rc);
! 583: }
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 / aviion / dev