Annotation of sys/arch/mvme68k/dev/nvram.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: nvram.c,v 1.17 2006/06/21 14:49:33 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: /*
29: * 8/22/2000 BH Cleaned up year 2000 problems with calendar hardware.
30: * This code will break again in 2068 or so - come dance on my grave.
31: */
32:
33: #include <sys/param.h>
34: #include <sys/systm.h>
35: #include <sys/kernel.h>
36: #include <sys/ioctl.h>
37: #include <sys/device.h>
38:
39: #include <machine/autoconf.h>
40: #include <machine/conf.h>
41: #include <machine/cpu.h>
42: #include <machine/mioctl.h>
43: #include <machine/psl.h>
44:
45: #include <uvm/uvm_extern.h>
46:
47: #include <mvme68k/dev/memdevs.h>
48: #include <mvme68k/dev/nvramreg.h>
49:
50: #if defined(GPROF)
51: #include <sys/gmon.h>
52: #endif
53:
54: struct nvramsoftc {
55: struct device sc_dev;
56: paddr_t sc_paddr;
57: vaddr_t sc_vaddr;
58: int sc_len;
59: struct clockreg *sc_regs;
60: };
61:
62: void nvramattach(struct device *, struct device *, void *);
63: int nvrammatch(struct device *, void *, void *);
64:
65: struct cfattach nvram_ca = {
66: sizeof(struct nvramsoftc), nvrammatch, nvramattach
67: };
68:
69: struct cfdriver nvram_cd = {
70: NULL, "nvram", DV_DULL
71: };
72:
73: int
74: nvrammatch(parent, vcf, args)
75: struct device *parent;
76: void *vcf, *args;
77: {
78: struct confargs *ca = args;
79:
80: /*X*/ if (ca->ca_vaddr == (vaddr_t)-1)
81: /*X*/ return (1);
82: return (!badvaddr(ca->ca_vaddr, 1));
83: }
84:
85: void
86: nvramattach(parent, self, args)
87: struct device *parent, *self;
88: void *args;
89: {
90: struct confargs *ca = args;
91: struct nvramsoftc *sc = (struct nvramsoftc *)self;
92:
93: sc->sc_paddr = ca->ca_paddr;
94: sc->sc_vaddr = (vaddr_t)ca->ca_vaddr;
95:
96: sc->sc_len = MK48T08_SIZE;
97: if (cputyp == CPU_147)
98: sc->sc_len = MK48T02_SIZE;
99:
100:
101: /*X*/ if (sc->sc_vaddr == -1)
102: /*X*/ sc->sc_vaddr = mapiodev(sc->sc_paddr, MAX(sc->sc_len, NBPG));
103: /*X*/ if (sc->sc_vaddr == 0)
104: /*X*/ panic("failed to map!");
105:
106: sc->sc_regs = (struct clockreg *)(sc->sc_vaddr + sc->sc_len -
107: sizeof(struct clockreg));
108:
109: printf(": MK48T0%d len %d\n", sc->sc_len / 1024, sc->sc_len);
110: }
111:
112: /*
113: * Return the best possible estimate of the time in the timeval
114: * to which tvp points. We do this by returning the current time
115: * plus the amount of time since the last clock interrupt (clock.c:clkread).
116: *
117: * Check that this time is no less than any previously-reported time,
118: * which could happen around the time of a clock adjustment. Just for fun,
119: * we guarantee that the time will be greater than the value obtained by a
120: * previous call.
121: */
122: void
123: microtime(tvp)
124: register struct timeval *tvp;
125: {
126: int s = splhigh();
127: static struct timeval lasttime;
128:
129: *tvp = time;
130: while (tvp->tv_usec >= 1000000) {
131: tvp->tv_sec++;
132: tvp->tv_usec -= 1000000;
133: }
134: if (tvp->tv_sec == lasttime.tv_sec &&
135: tvp->tv_usec <= lasttime.tv_usec &&
136: (tvp->tv_usec = lasttime.tv_usec + 1) >= 1000000) {
137: tvp->tv_sec++;
138: tvp->tv_usec -= 1000000;
139: }
140: lasttime = *tvp;
141: splx(s);
142: }
143:
144: /*
145: * BCD to decimal and decimal to BCD.
146: */
147: #define FROMBCD(x) (((x) >> 4) * 10 + ((x) & 0xf))
148: #define TOBCD(x) (((x) / 10 * 16) + ((x) % 10))
149:
150: #define SECYR (SECDAY * 365)
151: #define LEAPYEAR(y) (((y) & 3) == 0)
152:
153: /*
154: * This code is defunct after 2068.
155: * Will Unix still be here then??
156: */
157: const short dayyr[12] =
158: { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
159:
160: struct chiptime {
161: int sec;
162: int min;
163: int hour;
164: int wday;
165: int day;
166: int mon;
167: int year;
168: };
169:
170: u_long chiptotime(int, int, int, int, int, int);
171: void timetochip(struct chiptime *);
172:
173: u_long
174: chiptotime(sec, min, hour, day, mon, year)
175: register int sec, min, hour, day, mon, year;
176: {
177: register int days, yr;
178:
179: sec = FROMBCD(sec);
180: min = FROMBCD(min);
181: hour = FROMBCD(hour);
182: day = FROMBCD(day);
183: mon = FROMBCD(mon);
184: year = FROMBCD(year) + YEAR0;
185:
186: /* simple sanity checks */
187: if (year>164 || mon<1 || mon>12 || day<1 || day>31)
188: return (0);
189: yr = 70;
190: days = 0;
191:
192: if (year < 70) { /* 2000 <= year */
193: for (; yr < 100; yr++) /* deal with first 30 years */
194: days += LEAPYEAR(yr) ? 366 : 365;
195: yr = 0;
196: }
197:
198: for (; yr < year; yr++) /* deal with years left */
199: days += LEAPYEAR(yr) ? 366 : 365;
200:
201: days += dayyr[mon - 1] + day - 1;
202:
203: if (LEAPYEAR(yr) && mon > 2)
204: days++;
205:
206: /* now have days since Jan 1, 1970; the rest is easy... */
207: return (days * SECDAY + hour * 3600 + min * 60 + sec);
208: }
209:
210: void
211: timetochip(c)
212: struct chiptime *c;
213: {
214: int t, t2, t3, now = time.tv_sec;
215:
216: /* January 1 1970 was a Thursday (4 in unix wdays) */
217: /* compute the days since the epoch */
218: t2 = now / SECDAY;
219:
220: t3 = (t2 + 4) % 7; /* day of week */
221: c->wday = TOBCD(t3 + 1);
222:
223: /* compute the year */
224: t = 69;
225: while (t2 >= 0) { /* whittle off years */
226: t3 = t2;
227: t++;
228: t2 -= LEAPYEAR(t) ? 366 : 365;
229: }
230: c->year = t;
231:
232: /* t3 = month + day; separate */
233: t = LEAPYEAR(t);
234: for (t2 = 1; t2 < 12; t2++)
235: if (t3 < (dayyr[t2] + ((t && (t2 > 1)) ? 1:0)))
236: break;
237:
238: /* t2 is month */
239: c->mon = t2;
240: c->day = t3 - dayyr[t2 - 1] + 1;
241: if (t && t2 > 2)
242: c->day--;
243:
244: /* the rest is easy */
245: t = now % SECDAY;
246: c->hour = t / 3600;
247: t %= 3600;
248: c->min = t / 60;
249: c->sec = t % 60;
250:
251: c->sec = TOBCD(c->sec);
252: c->min = TOBCD(c->min);
253: c->hour = TOBCD(c->hour);
254: c->day = TOBCD(c->day);
255: c->mon = TOBCD(c->mon);
256: c->year = TOBCD((c->year - YEAR0) % 100);
257: }
258:
259: /*
260: * Set up the system's time, given a `reasonable' time value.
261: */
262: void
263: inittodr(base)
264: time_t base;
265: {
266: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[0];
267: register struct clockreg *cl = sc->sc_regs;
268: int sec, min, hour, day, mon, year;
269: int badbase = 0, waszero = base == 0;
270:
271: if (base < 5 * SECYR) {
272: /*
273: * If base is 0, assume filesystem time is just unknown
274: * instead of preposterous. Don't bark.
275: */
276: if (base != 0)
277: printf("WARNING: preposterous time in file system\n");
278: /* not going to use it anyway, if the chip is readable */
279: base = 21*SECYR + 186*SECDAY + SECDAY/2;
280: badbase = 1;
281: }
282: cl->cl_csr |= CLK_READ; /* enable read (stop time) */
283: sec = cl->cl_sec;
284: min = cl->cl_min;
285: hour = cl->cl_hour;
286: day = cl->cl_mday;
287: mon = cl->cl_month;
288: year = cl->cl_year;
289: cl->cl_csr &= ~CLK_READ; /* time wears on */
290: if ((time.tv_sec = chiptotime(sec, min, hour, day, mon, year)) == 0) {
291: printf("WARNING: bad date in nvram");
292: /*
293: * Believe the time in the file system for lack of
294: * anything better, resetting the clock.
295: */
296: time.tv_sec = base;
297: if (!badbase)
298: resettodr();
299: } else {
300: int deltat = time.tv_sec - base;
301:
302: if (deltat < 0)
303: deltat = -deltat;
304: if (waszero || deltat < 2 * SECDAY)
305: return;
306: printf("WARNING: clock %s %d days",
307: time.tv_sec < base ? "lost" : "gained", deltat / SECDAY);
308: }
309: printf(" -- CHECK AND RESET THE DATE!\n");
310: }
311:
312: /*
313: * Reset the clock based on the current time.
314: * Used when the current clock is preposterous, when the time is changed,
315: * and when rebooting. Do nothing if the time is not yet known, e.g.,
316: * when crashing during autoconfig.
317: */
318: void
319: resettodr()
320: {
321: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[0];
322: register struct clockreg *cl = sc->sc_regs;
323: struct chiptime c;
324:
325: if (!time.tv_sec || cl == NULL)
326: return;
327: timetochip(&c);
328: cl->cl_csr |= CLK_WRITE; /* enable write */
329: cl->cl_sec = c.sec;
330: cl->cl_min = c.min;
331: cl->cl_hour = c.hour;
332: cl->cl_wday = c.wday;
333: cl->cl_mday = c.day;
334: cl->cl_month = c.mon;
335: cl->cl_year = c.year;
336: cl->cl_csr &= ~CLK_WRITE; /* load them up */
337: }
338:
339: /*ARGSUSED*/
340: int
341: nvramopen(dev, flag, mode, p)
342: dev_t dev;
343: int flag, mode;
344: struct proc *p;
345: {
346: if (minor(dev) >= nvram_cd.cd_ndevs ||
347: nvram_cd.cd_devs[minor(dev)] == NULL)
348: return (ENODEV);
349: return (0);
350: }
351:
352: /*ARGSUSED*/
353: int
354: nvramclose(dev, flag, mode, p)
355: dev_t dev;
356: int flag, mode;
357: struct proc *p;
358: {
359:
360: return (0);
361: }
362:
363: /*ARGSUSED*/
364: int
365: nvramioctl(dev, cmd, data, flag, p)
366: dev_t dev;
367: u_long cmd;
368: caddr_t data;
369: int flag;
370: struct proc *p;
371: {
372: int unit = minor(dev);
373: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
374: int error = 0;
375:
376: switch (cmd) {
377: case MIOCGSIZ:
378: *(int *)data = sc->sc_len;
379: break;
380: default:
381: error = ENOTTY;
382: break;
383: }
384: return (error);
385: }
386:
387: /*ARGSUSED*/
388: int
389: nvramrw(dev, uio, flags)
390: dev_t dev;
391: struct uio *uio;
392: int flags;
393: {
394: int unit = minor(dev);
395: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
396:
397: return (memdevrw(sc->sc_vaddr, sc->sc_len, uio, flags));
398: }
399:
400: /*
401: * If the NVRAM is of the 2K variety, an extra 2K of who-knows-what
402: * will also be mmap'd, due to NBPG being 4K. On the MVME147 the NVRAM
403: * repeats, so userland gets two copies back-to-back.
404: */
405: paddr_t
406: nvrammmap(dev, off, prot)
407: dev_t dev;
408: off_t off;
409: int prot;
410: {
411: int unit = minor(dev);
412: struct nvramsoftc *sc = (struct nvramsoftc *) nvram_cd.cd_devs[unit];
413:
414: if (minor(dev) != 0)
415: return (-1);
416:
417: /* allow access only in RAM */
418: if (off < 0 || off > sc->sc_len)
419: return (-1);
420: return (atop(sc->sc_paddr + off));
421: }
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 / mvme68k / dev