devrtc.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461
  1. #include "u.h"
  2. #include "../port/lib.h"
  3. #include "mem.h"
  4. #include "dat.h"
  5. #include "fns.h"
  6. #include "../port/error.h"
  7. /*
  8. * real time clock and non-volatile ram
  9. */
  10. enum {
  11. Paddr= 0x70, /* address port */
  12. Pdata= 0x71, /* data port */
  13. Seconds= 0x00,
  14. Minutes= 0x02,
  15. Hours= 0x04,
  16. Mday= 0x07,
  17. Month= 0x08,
  18. Year= 0x09,
  19. Status= 0x0A,
  20. Nvoff= 128, /* where usable nvram lives */
  21. Nvsize= 256,
  22. Nbcd= 6,
  23. };
  24. typedef struct Rtc Rtc;
  25. struct Rtc
  26. {
  27. int sec;
  28. int min;
  29. int hour;
  30. int mday;
  31. int mon;
  32. int year;
  33. };
  34. enum{
  35. Qdir = 0,
  36. Qrtc,
  37. Qnvram,
  38. };
  39. Dirtab rtcdir[]={
  40. ".", {Qdir, 0, QTDIR}, 0, 0555,
  41. "nvram", {Qnvram, 0}, Nvsize, 0664,
  42. "rtc", {Qrtc, 0}, 0, 0664,
  43. };
  44. static ulong rtc2sec(Rtc*);
  45. static void sec2rtc(ulong, Rtc*);
  46. void
  47. rtcinit(void)
  48. {
  49. if(ioalloc(Paddr, 2, 0, "rtc/nvr") < 0)
  50. panic("rtcinit: ioalloc failed");
  51. }
  52. static Chan*
  53. rtcattach(char* spec)
  54. {
  55. return devattach('r', spec);
  56. }
  57. static Walkqid*
  58. rtcwalk(Chan* c, Chan *nc, char** name, int nname)
  59. {
  60. return devwalk(c, nc, name, nname, rtcdir, nelem(rtcdir), devgen);
  61. }
  62. static int
  63. rtcstat(Chan* c, uchar* dp, int n)
  64. {
  65. return devstat(c, dp, n, rtcdir, nelem(rtcdir), devgen);
  66. }
  67. static Chan*
  68. rtcopen(Chan* c, int omode)
  69. {
  70. omode = openmode(omode);
  71. switch((ulong)c->qid.path){
  72. case Qrtc:
  73. if(strcmp(up->user, eve)!=0 && omode!=OREAD)
  74. error(Eperm);
  75. break;
  76. case Qnvram:
  77. if(strcmp(up->user, eve)!=0)
  78. error(Eperm);
  79. }
  80. return devopen(c, omode, rtcdir, nelem(rtcdir), devgen);
  81. }
  82. static void
  83. rtcclose(Chan*)
  84. {
  85. }
  86. #define GETBCD(o) ((bcdclock[o]&0xf) + 10*(bcdclock[o]>>4))
  87. static long
  88. _rtctime(void)
  89. {
  90. uchar bcdclock[Nbcd];
  91. Rtc rtc;
  92. int i;
  93. /* don't do the read until the clock is no longer busy */
  94. for(i = 0; i < 10000; i++){
  95. outb(Paddr, Status);
  96. if(inb(Pdata) & 0x80)
  97. continue;
  98. /* read clock values */
  99. outb(Paddr, Seconds); bcdclock[0] = inb(Pdata);
  100. outb(Paddr, Minutes); bcdclock[1] = inb(Pdata);
  101. outb(Paddr, Hours); bcdclock[2] = inb(Pdata);
  102. outb(Paddr, Mday); bcdclock[3] = inb(Pdata);
  103. outb(Paddr, Month); bcdclock[4] = inb(Pdata);
  104. outb(Paddr, Year); bcdclock[5] = inb(Pdata);
  105. outb(Paddr, Status);
  106. if((inb(Pdata) & 0x80) == 0)
  107. break;
  108. }
  109. /*
  110. * convert from BCD
  111. */
  112. rtc.sec = GETBCD(0);
  113. rtc.min = GETBCD(1);
  114. rtc.hour = GETBCD(2);
  115. rtc.mday = GETBCD(3);
  116. rtc.mon = GETBCD(4);
  117. rtc.year = GETBCD(5);
  118. /*
  119. * the world starts jan 1 1970
  120. */
  121. if(rtc.year < 70)
  122. rtc.year += 2000;
  123. else
  124. rtc.year += 1900;
  125. return rtc2sec(&rtc);
  126. }
  127. static Lock nvrtlock;
  128. long
  129. rtctime(void)
  130. {
  131. int i;
  132. long t, ot;
  133. ilock(&nvrtlock);
  134. /* loop till we get two reads in a row the same */
  135. t = _rtctime();
  136. for(i = 0; i < 100; i++){
  137. ot = t;
  138. t = _rtctime();
  139. if(ot == t)
  140. break;
  141. }
  142. if(i == 100) print("we are boofheads\n");
  143. iunlock(&nvrtlock);
  144. return t;
  145. }
  146. static long
  147. rtcread(Chan* c, void* buf, long n, vlong off)
  148. {
  149. ulong t;
  150. char *a, *start;
  151. ulong offset = off;
  152. if(c->qid.type & QTDIR)
  153. return devdirread(c, buf, n, rtcdir, nelem(rtcdir), devgen);
  154. switch((ulong)c->qid.path){
  155. case Qrtc:
  156. t = rtctime();
  157. n = readnum(offset, buf, n, t, 12);
  158. return n;
  159. case Qnvram:
  160. if(n == 0)
  161. return 0;
  162. if(n > Nvsize)
  163. n = Nvsize;
  164. a = start = smalloc(n);
  165. ilock(&nvrtlock);
  166. for(t = offset; t < offset + n; t++){
  167. if(t >= Nvsize)
  168. break;
  169. outb(Paddr, Nvoff+t);
  170. *a++ = inb(Pdata);
  171. }
  172. iunlock(&nvrtlock);
  173. if(waserror()){
  174. free(start);
  175. nexterror();
  176. }
  177. memmove(buf, start, t - offset);
  178. poperror();
  179. free(start);
  180. return t - offset;
  181. }
  182. error(Ebadarg);
  183. return 0;
  184. }
  185. #define PUTBCD(n,o) bcdclock[o] = (n % 10) | (((n / 10) % 10)<<4)
  186. static long
  187. rtcwrite(Chan* c, void* buf, long n, vlong off)
  188. {
  189. int t;
  190. char *a, *start;
  191. Rtc rtc;
  192. ulong secs;
  193. uchar bcdclock[Nbcd];
  194. char *cp, *ep;
  195. ulong offset = off;
  196. if(offset!=0)
  197. error(Ebadarg);
  198. switch((ulong)c->qid.path){
  199. case Qrtc:
  200. /*
  201. * read the time
  202. */
  203. cp = ep = buf;
  204. ep += n;
  205. while(cp < ep){
  206. if(*cp>='0' && *cp<='9')
  207. break;
  208. cp++;
  209. }
  210. secs = strtoul(cp, 0, 0);
  211. /*
  212. * convert to bcd
  213. */
  214. sec2rtc(secs, &rtc);
  215. PUTBCD(rtc.sec, 0);
  216. PUTBCD(rtc.min, 1);
  217. PUTBCD(rtc.hour, 2);
  218. PUTBCD(rtc.mday, 3);
  219. PUTBCD(rtc.mon, 4);
  220. PUTBCD(rtc.year, 5);
  221. /*
  222. * write the clock
  223. */
  224. ilock(&nvrtlock);
  225. outb(Paddr, Seconds); outb(Pdata, bcdclock[0]);
  226. outb(Paddr, Minutes); outb(Pdata, bcdclock[1]);
  227. outb(Paddr, Hours); outb(Pdata, bcdclock[2]);
  228. outb(Paddr, Mday); outb(Pdata, bcdclock[3]);
  229. outb(Paddr, Month); outb(Pdata, bcdclock[4]);
  230. outb(Paddr, Year); outb(Pdata, bcdclock[5]);
  231. iunlock(&nvrtlock);
  232. return n;
  233. case Qnvram:
  234. if(n == 0)
  235. return 0;
  236. if(n > Nvsize)
  237. n = Nvsize;
  238. start = a = smalloc(n);
  239. if(waserror()){
  240. free(start);
  241. nexterror();
  242. }
  243. memmove(a, buf, n);
  244. poperror();
  245. ilock(&nvrtlock);
  246. for(t = offset; t < offset + n; t++){
  247. if(t >= Nvsize)
  248. break;
  249. outb(Paddr, Nvoff+t);
  250. outb(Pdata, *a++);
  251. }
  252. iunlock(&nvrtlock);
  253. free(start);
  254. return t - offset;
  255. }
  256. error(Ebadarg);
  257. return 0;
  258. }
  259. Dev rtcdevtab = {
  260. 'r',
  261. "rtc",
  262. devreset,
  263. rtcinit,
  264. devshutdown,
  265. rtcattach,
  266. rtcwalk,
  267. rtcstat,
  268. rtcopen,
  269. devcreate,
  270. rtcclose,
  271. rtcread,
  272. devbread,
  273. rtcwrite,
  274. devbwrite,
  275. devremove,
  276. devwstat,
  277. };
  278. #define SEC2MIN 60L
  279. #define SEC2HOUR (60L*SEC2MIN)
  280. #define SEC2DAY (24L*SEC2HOUR)
  281. /*
  282. * days per month plus days/year
  283. */
  284. static int dmsize[] =
  285. {
  286. 365, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  287. };
  288. static int ldmsize[] =
  289. {
  290. 366, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  291. };
  292. /*
  293. * return the days/month for the given year
  294. */
  295. static int*
  296. yrsize(int y)
  297. {
  298. if((y%4) == 0 && ((y%100) != 0 || (y%400) == 0))
  299. return ldmsize;
  300. else
  301. return dmsize;
  302. }
  303. /*
  304. * compute seconds since Jan 1 1970
  305. */
  306. static ulong
  307. rtc2sec(Rtc *rtc)
  308. {
  309. ulong secs;
  310. int i;
  311. int *d2m;
  312. secs = 0;
  313. /*
  314. * seconds per year
  315. */
  316. for(i = 1970; i < rtc->year; i++){
  317. d2m = yrsize(i);
  318. secs += d2m[0] * SEC2DAY;
  319. }
  320. /*
  321. * seconds per month
  322. */
  323. d2m = yrsize(rtc->year);
  324. for(i = 1; i < rtc->mon; i++)
  325. secs += d2m[i] * SEC2DAY;
  326. secs += (rtc->mday-1) * SEC2DAY;
  327. secs += rtc->hour * SEC2HOUR;
  328. secs += rtc->min * SEC2MIN;
  329. secs += rtc->sec;
  330. return secs;
  331. }
  332. /*
  333. * compute rtc from seconds since Jan 1 1970
  334. */
  335. static void
  336. sec2rtc(ulong secs, Rtc *rtc)
  337. {
  338. int d;
  339. long hms, day;
  340. int *d2m;
  341. /*
  342. * break initial number into days
  343. */
  344. hms = secs % SEC2DAY;
  345. day = secs / SEC2DAY;
  346. if(hms < 0) {
  347. hms += SEC2DAY;
  348. day -= 1;
  349. }
  350. /*
  351. * generate hours:minutes:seconds
  352. */
  353. rtc->sec = hms % 60;
  354. d = hms / 60;
  355. rtc->min = d % 60;
  356. d /= 60;
  357. rtc->hour = d;
  358. /*
  359. * year number
  360. */
  361. if(day >= 0)
  362. for(d = 1970; day >= *yrsize(d); d++)
  363. day -= *yrsize(d);
  364. else
  365. for (d = 1970; day < 0; d--)
  366. day += *yrsize(d-1);
  367. rtc->year = d;
  368. /*
  369. * generate month
  370. */
  371. d2m = yrsize(rtc->year);
  372. for(d = 1; day >= d2m[d]; d++)
  373. day -= d2m[d];
  374. rtc->mday = day + 1;
  375. rtc->mon = d;
  376. return;
  377. }
  378. uchar
  379. nvramread(int addr)
  380. {
  381. uchar data;
  382. ilock(&nvrtlock);
  383. outb(Paddr, addr);
  384. data = inb(Pdata);
  385. iunlock(&nvrtlock);
  386. return data;
  387. }
  388. void
  389. nvramwrite(int addr, uchar data)
  390. {
  391. ilock(&nvrtlock);
  392. outb(Paddr, addr);
  393. outb(Pdata, data);
  394. iunlock(&nvrtlock);
  395. }