![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mmu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / i386|
Return to mmu.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / i386 |
1.1 root 1: /*
2: * MMU dependent code for Coherent 386
3: *
4: * Copyright (c) Ciaran O'Donnell, Bievres (FRANCE), 1991
5: */
6:
7: #include <sys/coherent.h>
8: #include <sys/clist.h>
9: #include <errno.h>
10: #include <sys/inode.h>
11: #include <sys/seg.h>
12: #include <signal.h>
13: #include <sys/buf.h>
14: #include <sys/alloc.h>
15: #include <l.out.h>
16: #include <ieeefp.h>
17:
18: /* These defines belong somewhere else: */
19: #define LOMEM 0x15 /* CMOS address of size in K of memory below 1MB. */
20: #define EXTMEM 0x17 /* CMOS address of size in K of memory above 1MB. */
21: #define ONE_K 1024
22: #define ONE_MEG 1048576
23: #define USE_NDATA 1
24:
25: /*
26: * DMA will not work to memory above 16M, so limit the amount of memory
27: * above 1M to 15M. A much cleverer scheme should be implemented.
28: */
29: int HACK_LIMIT = (15*ONE_MEG);
30:
31: /*
32: * For 0 < i < 64, buddysize[i] is log(base 2) of nearest power of two
33: * which is greater than or equal to i.
34: */
35: char buddysize[64] = {
36: -1, 0, 1, 2, 2, 3, 3, 3,
37: 3, 4, 4, 4, 4, 4, 4, 4,
38: 4, 5, 5, 5, 5, 5, 5, 5,
39: 5, 5, 5, 5, 5, 5, 5, 5,
40: 5, 6, 6, 6, 6, 6, 6, 6,
41: 6, 6, 6, 6, 6, 6, 6, 6,
42: 6, 6, 6, 6, 6, 6, 6, 6,
43: 6, 6, 6, 6, 6, 6, 6, 6 };
44:
45: #define min(a, b) ((a) < (b) ? (a) : (b))
46:
47: /*
48: * Functions.
49: * Import.
50: * Export.
51: * Local.
52: */
53: void areacheck();
54: void areafree();
55: void areainit();
56: BLOCKLIST * arealloc();
57: int areasize();
58: cseg_t * c_alloc();
59: cseg_t * c_extend();
60: void c_free();
61: int c_grow();
62: int countsize();
63: void doload();
64: char * getPhysMem();
65: void i8086();
66: void idtinit();
67: void init_phy_seg();
68: void mchinit();
69: void msigend();
70: void msigstart();
71: void physMemInit();
72: SR *loaded();
73: unsigned int read16_cmos();
74: void segload();
75: void sunload();
76: void unload();
77: void valloc();
78:
79: #define zero_fill(from, len) memset(from, 0, len)
80:
81: /*
82: * "load" a handle "hp" to a segment into the space tree for a process
83: */
84: void
85: doload(srp)
86: register SR *srp;
87: {
88: register int n;
89: register cseg_t *pp;
90: register int base1, flags;
91: register int akey;
92:
93: pp = srp->sr_segp->s_vmem;
94: flags = srp->sr_segp->s_flags;
95: base1 = btocrd(srp->sr_base);
96: n = btoc(srp->sr_size);
97:
98: /*
99: * we load all pages
100: */
101: /* a shm segment ref may be Read-Write or Read-Only */
102: if (srp->sr_flag & SRFRODT)
103: akey = SEG_RO;
104: else {
105: switch (flags&(SFSYST|SFTEXT)) {
106: case SFTEXT: akey = SEG_RO; break;
107: case SFSYST: akey = SEG_SRW; break;
108: default: akey = SEG_RW; break;
109: }
110: }
111:
112: do
113: ptable1_v[base1++] = (*pp++ & ~SEG_NPL) | akey;
114: while (--n);
115: mmuupd();
116: }
117:
118: /*
119: * unload a handle key "key" to a segment from the MMU hardware
120: */
121: void
122: unload(srp)
123: register SR *srp;
124: {
125: register int n, base1;
126:
127: base1 = btocrd(srp->sr_base);
128:
129: n = btoc(srp->sr_size);
130: do {
131: ptable1_v[base1++] = SEG_ILL;
132: } while (--n);
133: mmuupd();
134: }
135:
136: /*
137: * Allocate 'clicks_wanted' clicks of core space.
138: * Returns physical segment descriptor if success, else NULL.
139: * The physical segment descriptor is a table of page table entries
140: * suitable for insertion into a page table.
141: */
142: cseg_t *
143: c_alloc(clicks_wanted)
144: unsigned clicks_wanted;
145: {
146: unsigned pno;
147: cseg_t *pp;
148: register cseg_t *qp;
149:
150: /* Do we have enough free physical clicks for this request? */
151: if (clicks_wanted > allocno())
152: goto no_c_alloc;
153:
154: /* Allocate some space for the table to return. */
155: if ((pp = (cseg_t *)arealloc(clicks_wanted)) == 0)
156: goto no_c_alloc;
157: qp = pp;
158:
159: /* fill in entries in the requested table */
160: do {
161: pno = *--sysmem.pfree;
162: if (!pvalid(pno))
163: panic("c_alloc");
164: *qp++ = (clickseg(pno) & ~SEG_BITS) | SEG_PRE;
165: } while (--clicks_wanted);
166: return pp;
167:
168: no_c_alloc:
169: return 0;
170: }
171:
172: /*
173: * Given an array "pp" containing "numClicks" click descriptors,
174: * if "pp" is the click list for a user segment currently loaded
175: * invalidate click entries for "pp" in the current page table
176: * return each click in "pp" to the sysmem pool, if it came from there.
177: * return the array "pp" to the buddy pool.
178: */
179: void
180: c_free(pp, numClicks)
181: cseg_t *pp;
182: unsigned numClicks;
183: {
184: unsigned pno;
185: register cseg_t *qp;
186: register int sz;
187: SR *srp;
188:
189: if (srp = loaded(pp)) {
190: unload(srp);
191: srp->sr_segp = 0;
192: }
193: sz = numClicks;
194: if (&sysmem.pfree[sz] > sysmem.efree)
195: panic("c_free - nalloc");
196: qp = pp;
197: do {
198: if ((*qp & SEG_NPL) == 0) {
199: pno = segclick(*qp);
200: if (!pvalid(pno))
201: panic("c_free");
202: *sysmem.pfree++ = pno;
203: } else {
204: T_HAL(0x40000, printf("c_free NPL %x ", *qp));
205: }
206: qp++;
207: } while (--sz);
208: areafree((BLOCKLIST *)pp, numClicks);
209: }
210:
211: /*
212: * Given a user virtual address, a physical address, and a byte
213: * count, map the specified virtual address into the user data
214: * page table for the current process.
215: *
216: * This is meant to be called from the console ioctl, KDMAPDISP.
217: * The user virtual address must be click aligned.
218: * The range of physical addresses must lie outside installed RAM
219: * or within the "PHYS_MEM" pool.
220: *
221: * Return 1 on success, else 0.
222: */
223: int
224: mapPhysUser(virtAddr, physAddr, numBytes)
225: {
226: int ret = 0;
227: SR * srp = u.u_segl + SIPDATA;
228: SEG * sp = srp->sr_segp;
229: cseg_t * pp = sp->s_vmem, * qp;
230: int pno, clickOffset, numClicks, i;
231:
232: /* Check alignment. */
233: if ((virtAddr & (NBPC-1)) || (physAddr & (NBPC-1))) {
234: T_HAL(0x40000, printf("mPU: failed alignment "));
235: goto mPUdone;
236: }
237:
238: /* Check validity of range of virtual addresses. */
239: if (virtAddr < srp->sr_base ||
240: (virtAddr + numBytes) >= (srp->sr_base + srp->sr_size)) {
241: T_HAL(0x40000, printf("mPU: bad vaddr "));
242: goto mPUdone;
243: }
244:
245: /* Check validity of range of physical addresses. */
246: /* if not in PHYS_MEM pool... */
247: if (!physValid(physAddr, numBytes)) {
248:
249: /* get installed RAM physical addresses */
250: unsigned int physLow = ctob((read16_cmos(LOMEM) + 3) >> 2);
251: unsigned int physHigh = ctob((read16_cmos(EXTMEM) + 3) >> 2)
252: + ONE_MEG;
253:
254: T_HAL(0x40000, printf("physLow=%x physHigh=%x ",
255: physLow, physHigh));
256:
257: /* Fail if physical range overlaps installed base RAM. */
258: if (physAddr < physLow) {
259: T_HAL(0x40000, printf("mPU: overlap base RAM "));
260: goto mPUdone;
261: }
262:
263: /* Fail if physical range overlaps installed extended RAM. */
264: if (physAddr < physHigh && (physAddr + numBytes) >= ONE_MEG) {
265: T_HAL(0x40000, printf("mPU: overlap extended RAM "));
266: goto mPUdone;
267: }
268: }
269:
270: /*
271: * For each click in user data segment which is to be remapped
272: * if current click was taken from sysmem pool
273: * return current click to sysmem pool
274: * write new physical address into current click entry
275: * mark current click as not coming from sysmem pool
276: * map current click into page table
277: */
278: clickOffset = btocrd(virtAddr - srp->sr_base);
279: numClicks = numBytes >> BPCSHIFT;
280: for (qp = pp + clickOffset, i = 0; i < numClicks; i++, qp++) {
281: if ((*qp & SEG_NPL) == 0) {
282: pno = segclick(*qp);
283: if (!pvalid(pno)) {
284: T_HAL(0x40000, printf("mPU: bad release "));
285: } else {
286: *sysmem.pfree++ = pno;
287: T_HAL(0x40000,
288: printf("mPU: freeing virtual click %x ",
289: virtAddr + ctob(i)));
290: }
291: } else {
292: T_HAL(0x40000,
293: printf("mPU: rewriting virtual NPL click %x ",
294: virtAddr + ctob(i)));
295: }
296: *qp = (physAddr + ctob(i)) | (SEG_RW | SEG_NPL);
297: ptable1_v[btocrd(virtAddr) + i] = *qp;
298: }
299: mmuupd();
300: ret = 1;
301:
302: mPUdone:
303: return ret;
304: }
305:
306: /*
307: * Add a click to a segment.
308: * Enlarge buddy table for segment, if needed.
309: *
310: * Arguments:
311: * pp points to segment reference table (segp->s_vmem, e.g.)
312: * osz is old segment size, in clicks
313: *
314: * Return pointer to enlarged segment reference table, or NULL if failed.
315: */
316: cseg_t *
317: c_extend(pp, osz)
318: register cseg_t *pp;
319: int osz;
320: {
321: register cseg_t *pp1;
322: register unsigned pno;
323: register int i;
324: SR *srp;
325:
326: /* Fail if no more free clicks available. */
327: if (sysmem.pfree < &sysmem.tfree[1])
328: goto no_c_extend;
329:
330: /* Don't grow segment beyond hardware segment size (4 megabytes). */
331: if (osz >= (NBPS/NBPC))
332: goto no_c_extend;
333:
334: if (srp = loaded(pp)) {
335: unload(srp);
336: srp->sr_segp = 0;
337: }
338:
339: /*
340: * If the old size was a power of 2, it has used up an entire
341: * buddy area, so we will need to allocate more space.
342: */
343: if (IS_POW2(osz)) {
344: if ((pp1 = (cseg_t*) arealloc(osz+1))==0)
345: goto no_c_extend;
346: for (i=0; i < osz; i++)
347: pp1[i] = pp[i];
348: areafree(pp, osz);
349: pp = pp1;
350: }
351:
352: for (i=osz; --i >= 0;)
353: pp[i+1] = pp[i];
354:
355: pno = *--sysmem.pfree;
356: if (!pvalid(pno))
357: panic("c_extend");
358: pp[0] = clickseg(pno) | SEG_RW;
359: return pp;
360:
361: no_c_extend:
362: return 0;
363: }
364:
365: /*
366: * Given segment size in bytes, estimate total space needed
367: * to keep track of the segment (I think - hws).
368: *
369: * return value is num_bytes plus some overhead...
370: */
371: int
372: countsize(num_bytes)
373: int num_bytes;
374: {
375: int ret;
376:
377: if (num_bytes <= NBPC/sizeof(long))
378: ret = num_bytes+1;
379: else
380: ret = num_bytes
381: + ((num_bytes + NBPC/sizeof(long) - 1) >> BPC1SHIFT) + 1;
382: return ret;
383: }
384:
385: /*
386: * buddy allocation
387: */
388:
389: /*
390: * Deallocate a segment descriptor area.
391: * "sp" is not really a BLOCKLIST*, rather a cseg_t *.
392: * "numClicks" is the number of clicks referenced in the area.
393: */
394: void
395: areafree(sp, numClicks)
396: BLOCKLIST *sp;
397: int numClicks;
398: {
399: register int n; /* adresse du buddy, taille du reste */
400: register int ix, nx;
401: register BLOCKLIST *buddy;
402:
403: areacheck(2, sp);
404:
405: /*
406: * Pointer "sp" points to an element in the sysmem table of
407: * free clicks.
408: * Integer "ix" is the index of "sp" into that table.
409: * Will use "ix" to index into one or more buddy tables.
410: */
411: ix = sp - sysmem.u.budtab;
412: n = areasize(numClicks);
413: do {
414: /* "nx" is index of buddy element to the one at "ix". */
415: nx = BUDDY(ix, n);
416: if (sysmem.budfree[nx>>WSHIFT] & 1<<(nx&(WCOUNT-1))) {
417: /* coalesce two buddies */
418: buddy = sysmem.u.budtab + nx;
419: if (buddy->kval != n)
420: break;
421: sysmem.budfree[nx>>WSHIFT] &= ~ (1<<(nx & (WCOUNT-1)));
422: DELETE2(buddy);
423: if (nx < ix)
424: ix = nx;
425: } else
426: break;
427: } while (++n < NBUDDY);
428: sysmem.budfree[ix>>WSHIFT] |= 1 << (ix & (WCOUNT-1));
429: buddy = sysmem.u.budtab + ix;
430: INSERT2(BLOCKLIST, buddy, &sysmem.bfree[n]);
431: buddy->kval = n;
432: areacheck(3, buddy);
433: }
434:
435: /*
436: * arealloc()
437: *
438: * Given size in "clicks" of a segment to manage,
439: * return pointer to an array of enough descriptors.
440: * If not enough free descriptors available, return 0.
441: */
442: BLOCKLIST *
443: arealloc(clicks)
444: register int clicks;
445: {
446: register BLOCKLIST *sp;
447: register BLOCKLIST *p, *q;
448: register int size;
449: BLOCKLIST *rsp;
450: register int nx;
451:
452: areacheck(0, 0);
453: size = areasize(clicks);
454: /*
455: * 1. Find little end, bloc p, free >= size
456: */
457: for (q = p = sysmem.bfree + size;p->forw == p; size++, p++)
458: if (p >= sysmem.bfree + NBUDDY - 1) {
459: return(0); /* y en a pas */
460: }
461:
462: rsp = p->forw;
463: DELETE2(rsp);
464: nx = rsp - sysmem.u.budtab;
465: sysmem.budfree[nx>>WSHIFT] &= ~(1 << (nx & (WCOUNT-1)));
466: size = 1<<size;
467: sp = rsp + size; /* buddy address */
468: while (p-- != q) {
469: /*
470: * 2.1 The block is too big, uncouple & free buddy
471: */
472: sp -= (size >>= 1);
473: nx = sp - sysmem.u.budtab;
474: sysmem.budfree[nx>>WSHIFT] |= 1 << (nx & (WCOUNT-1));
475: INSERT2(BLOCKLIST, sp, p);
476: sp->kval = p - sysmem.bfree;
477: }
478: areacheck(1, rsp);
479: return rsp;
480: }
481:
482: void
483: areainit(n)
484: {
485: extern char __end[];
486: register int i;
487:
488: for (i=0; i < (1<<(NBUDDY-WSHIFT)); i++)
489: sysmem.budfree[i] = 0;
490: for (i=0; i<NBUDDY; i++)
491: INIT2(&sysmem.bfree[i]);
492: sysmem.u.budtab = (BLOCKLIST *)__end;
493: n /= sizeof(BLOCKLIST);
494: if (n > (1 << NBUDDY))
495: panic("areainit");
496: for (i=0; i<n; i++)
497: areafree(&sysmem.u.budtab[i], sizeof(BLOCKLIST)/sizeof(long));
498: }
499:
500: /*
501: * areasize()
502: *
503: * Do a log(base 2) calculation on n.
504: * If n is zero, return -1.
505: *
506: * Else, consider the nearest power of two which is greater than or
507: * equal to n
508: * p/2 < n <= p
509: * Then set p = 4 * (2**x). Note BLKSZ is 2.
510: * Return max(x,0).
511: *
512: * If n is too large (more than 3F00), we will go beyond the limits of
513: * table buddysize[].
514: *
515: * In practice, n is the total number of clicks needed in a segment,
516: * and the return value will be used to access a buddy system list.
517: */
518: int
519: areasize(n)
520: register unsigned int n;
521: {
522: register int m;
523: #ifdef FROTZ
524: int ret, oldn = n;
525: #endif
526:
527: if (n > 0x3F00)
528: panic("areasize");
529:
530: n = (n + (1 << BLKSZ) - 1) >> BLKSZ;
531: m = n & 0x3F;
532: #ifdef FROTZ
533: if ((n >>= 6) == 0)
534: ret = buddysize[m];
535: else {
536: int index;
537:
538: index = n;
539: if (m)
540: index++;
541: ret = buddysize[index] + 6;
542: }
543: return ret;
544: #else
545: if ((n >>= 6) == 0)
546: return buddysize[m];
547: return buddysize[n + ((m!=0)?1:0)] + 6;
548: #endif
549: }
550:
551: #define MAXBUDDY 2048
552: #define CHECK(p) ((p>=&sysmem.bfree[0] && p<&sysmem.bfree[NBUDDY]) || \
553: (p>=sysmem.u.budtab && p<&sysmem.u.budtab[1<<NBUDDY]))
554: void
555: areacheck(flag, sp)
556: register BLOCKLIST *sp;
557: {
558: register BLOCKLIST *next, *start;
559: register int i, nx;
560:
561: if (sp) {
562: if (&sysmem.u.budtab[sp-sysmem.u.budtab] != sp)
563: printf("*check* %d %x %x\n", flag, sp, sysmem.u.budtab);
564: }
565:
566: for (i=0; i<NBUDDY; i++) {
567: start = next = &sysmem.bfree[i];
568: do {
569: next = next->forw;
570: if (!CHECK(next))
571: printf("next = %x (%d)\n", next, flag);
572: if (next->back != start)
573: printf("%x->forw->back != %x\n", next, start);
574: if (next != &sysmem.bfree[i]) {
575: if (next->kval != i)
576: printf("bad kval %x, %d (%d)\n",
577: next, next->kval, flag);
578: nx = next - sysmem.u.budtab;
579: if ((sysmem.budfree[nx>>WSHIFT] & (1 << (nx & (WCOUNT-1)))) == 0)
580: printf("in bfree but not budfree %x (%d)\n", next, flag);
581: }
582: start = next;
583: } while (next != &sysmem.bfree[i]);
584: }
585: }
586:
587: MAKESR(physMem, _physMem);
588: int PHYS_MEM = 0; /* Number of bytes of contiguous RAM needed */
589:
590: /*
591: * A block of contiguous physical memory has been allocated for special
592: * i/o devices.
593: * Problem: clicks of physical memory are in reverse order in the
594: * page table.
595: * This routine reverses the page table entries for the pages
596: * involved. It relies *heavily* on all pages having virtual addresses
597: * in the FFCx xxxx segment.
598: *
599: * If all goes well, assign physAvailStart to the virtual address of
600: * the beginning of the region, and physAvailBytes to the number of bytes
601: * in the region. Otherwise, leave physAvailStart and physAvailBytes at 0.
602: *
603: * As memory is allocated, physAvailStart advances to point to the next
604: * available byte of contiguous memory, physAvailBytes is decremented,
605: * and physPoolStart remains set to the virtual address of the start of
606: * the contiguous pool.
607: */
608: static int physPoolStart; /* start of contiguous memory area */
609: static int physAvailStart; /* next free byte in contiguous memory area */
610: static int physAvailBytes; /* number of bytes in contiguous memory area */
611:
612: /*
613: * Check whether a range of physical addresses lies within the
614: * pool of contiguous physical memory.
615: */
616: int
617: physValid(base, numBytes)
618: unsigned int base, numBytes;
619: {
620: int vpool;
621: int ret = 0;
622:
623: if (PHYS_MEM) {
624: vpool = vtop(physPoolStart);
625: T_HAL(0x40000, printf("PHYS_MEM phys addrs %x to %x ",
626: vpool, vpool + PHYS_MEM));
627: if (base >= vpool && (base + numBytes) <= (vpool + PHYS_MEM))
628: ret = 1;
629: } else {
630: T_HAL(0x40000, printf("No PHYS_MEM "));
631: }
632:
633: T_HAL(0x40000, printf("physValid(%x, %x) = %d ", base, numBytes, ret));
634: return ret;
635: }
636:
637: void
638: physMemInit()
639: {
640: int m, vaddr;
641: int err = 0, num_clicks = btoc(PHYS_MEM);
642: int prevPaddr, paddr;
643:
644: /*
645: * Going half way into page table for physMem
646: * If entry and its complementary entry aren't both in top segment
647: * Error exit (no phys mem will be available).
648: * Get page table entries and swap them.
649: */
650: for (m = 0; m < num_clicks/2; m++) {
651: int m2 = num_clicks - 1 - m; /* complementary index */
652:
653: /* compute virtual addresses */
654: int lo_addr = physMem.sr_base + ctob(m);
655: int hi_addr = physMem.sr_base + ctob(m2);
656:
657: /* compute indices into page table (ptable1_v) */
658: int lo_p1ix = btocrd(lo_addr);
659: int hi_p1ix = btocrd(hi_addr);
660:
661: /* fetch physical addresses from page table */
662: int lo_paddr = ptable1_v[lo_p1ix];
663: int hi_paddr = ptable1_v[hi_p1ix];
664:
665: /* abort if either address is not in top segment */
666: if (btosrd(lo_addr) != 0x3FF) {
667: err = 1;
668: break;
669: }
670: if (btosrd(hi_addr) != 0x3FF) {
671: err = 1;
672: break;
673: }
674:
675: /* exchange page table entries */
676: ptable1_v[lo_p1ix] = hi_paddr;
677: ptable1_v[hi_p1ix] = lo_paddr;
678: }
679:
680: /*
681: * Final sanity check.
682: * In case someone gets creative with startup code, check
683: * again here that the memory is actually contiguous.
684: */
685: prevPaddr = vtop(physMem.sr_base);
686: for (m = 0; m < num_clicks - 1; m++) {
687: paddr = vtop(physMem.sr_base + ctob(m + 1));
688: if (paddr - prevPaddr != NBPC) {
689: err = 1;
690: break;
691: }
692: prevPaddr = paddr;
693: }
694:
695: if (!err) {
696: physPoolStart = physAvailStart = physMem.sr_base;
697: physAvailBytes = PHYS_MEM;
698: }
699: }
700:
701: /*
702: * Return virtual address of block of contiguous physical memory.
703: * If request cannot be granted, return 0.
704: *
705: * Expect physMem resource to be granted during load routine of device
706: * drivers. Once allocated, memory is not returned to the physMem pool.
707: */
708: char *
709: getPhysMem(numBytes)
710: unsigned int numBytes;
711: {
712: char * ret = NULL;
713:
714: if (numBytes <= physAvailBytes) {
715: ret = (char *)physAvailStart;
716: physAvailStart += numBytes;
717: physAvailBytes -= numBytes;
718: } else
719: printf("getPhysMem failed - %d additional bytes "
720: "PHYS_MEM needed\n", physAvailBytes - numBytes);
721: return ret;
722: }
723:
724: /*
725: * Return virtual address of aligned block of contiguous physical memory.
726: * Mainly for devices using the stupid Intel DMA hardware without
727: * scatter/gather.
728: * If request cannot be granted, return 0.
729: *
730: * Argument "align" says what physical boundary we need alignment on.
731: * It must be a power of 2.
732: * For 4k alignment, align = 4k, etc.
733: * Sorry, but will throw away memory to get to the next acceptable address.
734: *
735: * Once allocated, memory is not returned to the physMem pool.
736: */
737: char *
738: getDmaMem(numBytes, align)
739: unsigned int numBytes;
740: unsigned int align;
741: {
742: char * ret = NULL;
743: int wastedBytes, neededBytes;
744:
745: if (align == 0) {
746: printf("getDmaMem(0) (?)\n");
747: goto getDmaMemDone;
748: }
749:
750: if (!IS_POW2(align)) {
751: printf("getDmaMem(%x) (?)\n", align);
752: goto getDmaMemDone;
753: }
754:
755: /*
756: * Waste RAM from bottom of pool up to physical
757: * address with desired alignment.
758: */
759: wastedBytes = align - (vtop(physAvailStart) % align);
760: neededBytes = numBytes + wastedBytes;
761:
762: if (neededBytes <= physAvailBytes) {
763: ret = (char *)physAvailStart + wastedBytes;
764: physAvailStart += neededBytes;
765: physAvailBytes -= neededBytes;
766: } else
767: printf("getDmaMem failed - %d additional bytes "
768: "PHYS_MEM needed\n", physAvailBytes - neededBytes);
769:
770: getDmaMemDone:
771: return ret;
772: }
773: /***************/
774:
775: #undef ptable1_v
776:
777: /*
778: * pageDir is the physical address of the click in use for the page
779: * directory, offset by ctob(SBASE - PBASE)
780: */
781: #define pageDir ((long *)(&stext[ctob(-1)]))
782:
783: int total_clicks; /* How many clicks did we start with? */
784:
785: void
786: mchinit()
787: {
788: extern char __end[], __end_data[], stext[], __end_text[], sdata[];
789: extern int RAM0, RAMSIZE;
790:
791: int lo; /* Number of bytes of physical memory below 640K. */
792: int hi; /* Number of bytes of physical memory above 1M. */
793: register char *pe;
794: register int zero = 0;
795: register int i;
796: register long *ptable1_v;
797: register unsigned short base;
798: int sysseg, codeseg, stackseg, ramseg, ptable1;
799: int ptoff; /* An offset into pageDir[] */
800: #if USE_NDATA
801: int dataseg[NDATA];
802: #else
803: int dataseg;
804: #endif
805: int nalloc;
806: extern char digtab[];
807: static SEG uinit;
808: int budArenaBytes; /* number of bytes in buddy pool */
809: int kerBytes; /* number of bytes in kernel text and data */
810:
811: /*
812: * 1.
813: * a. Relocate the data on a page boundary (4K bytes) the
814: * bootstrap relocates it on a paragraph boundary (16 bytes)
815: *
816: * b. Verify that the data has been relocated correctly
817: */
818: pe = __end_data; /* 1.a */
819: i = (((unsigned)__end_text+15) & ~15) - (unsigned)sdata;
820: do {
821: pe--;
822: pe[0] = pe[i];
823: } while (pe != sdata); /* 1.b */
824:
825: /*
826: * Can now access the .data segment from C.
827: * If not, next loop will hang the kernel.
828: */
829: CHIRP('A');
830: while (digtab[0]!='0');
831: CHIRP('*');
832:
833: /* Zero the bss. */
834: pe = __end_data;
835: do
836: *pe++ = zero;
837: while (pe != __end);
838:
839: /*
840: * Zero the level 0 page directory, which occupies the click
841: * of virtual space immediately below kernel text.
842: */
843: pe = (char *) pageDir;
844: do
845: *pe++ = zero;
846: while (pe != stext);
847:
848: CHIRP('2');
849:
850: /*
851: * 3. Calculate total system memory.
852: * Count the space used by the system and the page
853: * descriptors, the interrupt stack, and the refresh work area
854: *
855: * a. initialize allocation area and adjust system size
856: * to take allocation area and free page area into account
857: */
858:
859: /*
860: * btoc(__end) - SBASE is the number of clicks in kernel text
861: * plus data, rounded up.
862: * PBASE is the starting physical click number of the kernel.
863: *
864: * Set sysmem.lo to the physical click address just past the kernel.
865: */
866: DV(__end);
867:
868: kerBytes = __end - ((SBASE - PBASE)<<BPCSHIFT);
869: DV(kerBytes);
870:
871: sysmem.lo = btoc(kerBytes);
872: DV(sysmem.lo);
873:
874: /*
875: * lo is the size in bytes of memory between the end of the kernel
876: * and the end of memory below 640K.
877: * hi is the size in bytes of memory over 1 Megabyte (Extended memory).
878: *
879: * Round the sizes from the CMOS down to the next click. This
880: * compensates for systems where the CMOS reports sizes that are
881: * not multiples of 4K.
882: */
883: DV(read16_cmos(LOMEM));
884: lo = ctob(read16_cmos(LOMEM) >> 2) - ctob(sysmem.lo);
885: DV(lo);
886:
887: DV(read16_cmos(EXTMEM));
888: hi = ctob(read16_cmos(EXTMEM) >> 2);
889: DV(hi);
890:
891: /*
892: * Sometimes, we die horribly if there is too much memory.
893: * Artificially limit hi to HACK_LIMIT.
894: */
895: if (hi > HACK_LIMIT)
896: hi = HACK_LIMIT;
897:
898: /* clear base memory above the kernel */
899: CHIRP('z');
900: zero_fill(ctob(sysmem.lo+SBASE-PBASE), lo);
901: CHIRP('Z');
902:
903: /* clear extended memory */
904: zero_fill(ONE_MEG+ctob(SBASE-PBASE), hi);
905: CHIRP('Y');
906:
907: /* Record total memory for later use. */
908: total_mem = ctob(sysmem.lo) + lo + hi;
909: DV(total_mem);
910:
911: /*
912: * sysmem.pfree and relatives will keep track of a pool of 4k pages
913: * assigned to processes, hereinafter known as the sysmem pool.
914: * How many clicks can go into this pool? nalloc.
915: * Allow NBPC for the click itself, a short for the sysmem pointer,
916: * and SPLASH*sizeof(long) for buddy system overhead.
917: */
918: nalloc = (lo+hi) / (sizeof(short) + SPLASH*sizeof(long) + NBPC);
919: DV(nalloc);
920:
921: /*
922: * ASSERT:
923: * For the moment we want only to assure that the
924: * BUDDY arena and the stack of free pages will fit below
925: * 640K.
926: */
927: budArenaBytes = SPLASH*nalloc*sizeof(long);
928: DV(budArenaBytes);
929:
930: #define SIZEOF_FREE_PAGES ((btoc(hi) + btoc(lo))* sizeof(short))
931: T_PIGGY(0x800, {
932: if (budArenaBytes + SIZEOF_FREE_PAGES >= lo) {
933: panic("Too much memory");
934: }
935: });
936:
937: /*
938: * Initialize the buddy system arena. This memory is used
939: * for the compressed page tables.
940: */
941: areainit(budArenaBytes);
942:
943: /*
944: * Initialize the stack of free pages.
945: * __end is the virtual address just past kernel data
946: * Point sysmem.tfree to the lowest virtual address just above
947: * the buddy pool, and initialize sysmem.pfree there.
948: */
949: sysmem.tfree = sysmem.pfree =
950: (unsigned short *)(__end + budArenaBytes);
951: DV(sysmem.tfree);
952:
953: /* sysmem.hi is the physical click number just past high RAM */
954: sysmem.hi = btoc(hi+ONE_MEG);
955: DV(sysmem.hi);
956:
957: /* base is the physical click number just past base RAM */
958: base = sysmem.lo + (lo>>BPCSHIFT);
959: DV(base);
960:
961: /*
962: * Adjust sysmem.lo to be the physical click number just above
963: * not just the kernel, but above sysmem overhead as well.
964: */
965: sysmem.lo = btoc(kerBytes + budArenaBytes + nalloc*sizeof(short));
966: DV(sysmem.lo);
967:
968: /*
969: * sysmem.vaddre is the virtual address of the next click after the
970: * kernel.
971: */
972: sysmem.vaddre = ctob(sysmem.lo+SBASE-PBASE);
973: DV(sysmem.vaddre);
974:
975: /* include in system area pages for arena, free area */
976:
977: CHIRP('3');
978:
979: /*
980: * 4.
981: * Free the memory from [end, 640) kilobytes
982: * Free the memory from [1024, 16*1024) kilobytes
983: *
984: * We are building a stack of free pages bounded below
985: * by sysmem.tfree and above by sysmem.efree. sysmem.pfree
986: * is the top of the stack. The stack grows upwards.
987: */
988: total_clicks = 0;
989:
990: /*
991: * Initialize the sysmem table (phase 1 - base RAM).
992: * Put base RAM above the kernel and sysmem overhead area into
993: * sysmem pool.
994: */
995: while (base > sysmem.lo) {
996: *sysmem.pfree++ = --base;
997: ++total_clicks;
998: }
999:
1000: /*
1001: * Initialize the sysmem table (phase 2 - extended RAM).
1002: * Put all extended RAM into the sysmem pool.
1003: */
1004: base = btoc(ONE_MEG);
1005: while (base < sysmem.hi && total_clicks < nalloc) {
1006: *sysmem.pfree++ = base++;
1007: ++total_clicks;
1008: }
1009: DV(total_clicks);
1010:
1011: /*
1012: * Roundoff error may have made nalloc smaller than necessary.
1013: */
1014: while(base < sysmem.hi) {
1015: if (sysmem.pfree + 1 >= sysmem.vaddre)
1016: break;
1017: *sysmem.pfree++ = base++;
1018: ++total_clicks;
1019: nalloc++;
1020: }
1021: DV(total_clicks);
1022: DV(nalloc);
1023:
1024: /*
1025: * sysmem.efree points just past the last pointer in the sysmem
1026: * table.
1027: */
1028: sysmem.efree = sysmem.pfree;
1029: DV(sysmem.efree);
1030: DV(allocno());
1031:
1032: T_PIGGY(0x800, {
1033: /*
1034: * ASSERT: The stack of free pages should end within a click
1035: * of the lowest available memory.
1036: */
1037: if ((cseg_t *)ctob(sysmem.lo+SBASE-PBASE) < sysmem.efree) {
1038: panic("sysmem.lo is too low");
1039: }
1040:
1041: if (sysmem.efree < (cseg_t *)ctob(sysmem.lo+SBASE-PBASE - 1)){
1042: panic("sysmem.efree is too low");
1043: }
1044:
1045: /*
1046: * ASSERT: There should be nalloc total_clicks.
1047: */
1048: if (nalloc != total_clicks) {
1049: panic("nalloc != total_clicks ");
1050: }
1051: });
1052:
1053: CHIRP('4');
1054:
1055: /*
1056: * 5. allocate page entries and initialize level 0 ^'s
1057: * a. [ 00000000 .. 003FFFFF) user code segment
1058: * b. [ 00400000 .. 007FFFFF) user data & bss
1059: * c. [ 7FC00000 .. 7FFFFFFF) user stack
1060: *c.i.[ 80000000 .. 80FFFFFF) ram disk
1061: * d. [ FF800000 .. FFBFFFFF) pointers to level 1 page table
1062: * e. [ FFC00000 .. FFFFFFFF) system process addresses
1063: */
1064: codeseg = clickseg(*--sysmem.pfree); /* 5.a */
1065: pageDir[0x000] = codeseg | DIR_RW;
1066:
1067: #if USE_NDATA
1068: for (i = 0; i < NDATA; i++) {
1069: dataseg[i] = clickseg(*--sysmem.pfree); /* 5.b */
1070: pageDir[0x001+i] = dataseg[i] | DIR_RW;
1071: }
1072: #else
1073: dataseg = clickseg(*--sysmem.pfree); /* 5.b */
1074: pageDir[0x001] = dataseg | DIR_RW;
1075: #endif
1076:
1077: stackseg = clickseg(*--sysmem.pfree); /* 5.c */
1078: pageDir[0x1FF] = stackseg | DIR_RW;
1079:
1080: /*
1081: * ptable1 is a handle for the click containing page table
1082: * entries for the page table.
1083: *
1084: * allocate a click for ptable1
1085: * Then point at it from the page directory.
1086: */
1087: ptable1 = clickseg(*--sysmem.pfree); /* 5.d */
1088: pageDir[0x3FE] = ptable1 | DIR_RW;
1089:
1090: sysseg = clickseg(*--sysmem.pfree); /* 5.e */
1091: pageDir[0x3FF] = sysseg | DIR_RW;
1092:
1093: CHIRP('5');
1094:
1095: /*
1096: * 6. initialize level 2 ^'s to [5.d]
1097: */
1098:
1099: ptable1_v = (long *)(ptable1 + ctob(SBASE-PBASE));
1100: DV(pageDir);
1101: DV(ptable1_v);
1102: ptable1_v[0x000] = codeseg | SEG_SRW;
1103: #if USE_NDATA
1104: for (i = 0; i < NDATA; i++)
1105: ptable1_v[0x001+i] = dataseg[i] | SEG_SRW;
1106: #else
1107: ptable1_v[0x001] = dataseg | SEG_SRW;
1108: #endif
1109: ptable1_v[0x1FF] = stackseg| SEG_SRW;
1110:
1111: /*
1112: * This ram disk stuff should go away once the scheme
1113: * for allocating pieces of virtual memory space is in place.
1114: */
1115: for (ptoff = btosrd(RAM0) & 0x3ff;
1116: ptoff < (btosrd(RAM0 + 2 * RAMSIZE) & 0x3ff); ++ptoff) {
1117: ramseg = clickseg(*--sysmem.pfree); /* 5.c.i */
1118: pageDir[ptoff] = ramseg | DIR_RW;
1119: ptable1_v[ptoff] = ramseg | SEG_SRW;
1120: }
1121:
1122: ptable1_v[0x3FF] = sysseg | SEG_SRW;
1123:
1124: CHIRP('6');
1125:
1126: /*
1127: * 7.
1128: * b. map kernel code and data
1129: * map ^ to:
1130: * c. level 0 page table
1131: * d. level 1 page table
1132: * e. I/O segments (video RAM, ...)
1133: */
1134:
1135: ptable1_v = (long *)(sysseg + ctob(SBASE-PBASE)); /* 7.b */
1136: DV(ptable1_v);
1137: for (i = PBASE; i <sysmem.lo; i++)
1138: ptable1_v[i-PBASE] = clickseg(i) | SEG_SRW;
1139:
1140: ptable1_v[0x3FE] = clickseg(PTABLE0_P) | SEG_SRW; /* 7.c */
1141: ptable1_v[0x3FD] = ptable1 | SEG_SRW; /* 7.d */
1142:
1143: init_phy_seg(ptable1_v, ROM-SBASE, 0x0000F0000); /* 7.e. */
1144: init_phy_seg(ptable1_v, VIDEOa-SBASE,0x0000B0000);
1145: init_phy_seg(ptable1_v, VIDEOb-SBASE,0x0000B8000);
1146:
1147: CHIRP('7');
1148:
1149: /*
1150: * 8. allocate and map U area
1151: */
1152:
1153: uinit.s_flags = SFSYST|SFCORE;
1154: uinit.s_size = UPASIZE;
1155: uinit.s_vmem = c_alloc(btoc(UPASIZE));
1156: ptable1_v[0x3FF] = *uinit.s_vmem | SEG_SRW;
1157: procq.p_segp[SIUSERP] = &uinit;
1158:
1159: CHIRP('8');
1160:
1161: /*
1162: * 9. make FFC00000 and 00002000 map to the same address
1163: * to prevent the prefetch after the instruction turning on
1164: * paging from causing a page fault
1165: */
1166: ptable1_v = (long *)(codeseg + ctob(SBASE-PBASE));
1167: DV(ptable1_v);
1168: ptable1_v[PBASE] = clickseg(PBASE) | SEG_SRW;
1169:
1170: CHIRP('9');
1171:
1172: /*
1173: * 10. load page table base address into MMU
1174: * fix up the interrupt vectors
1175: */
1176: mmuupdnR0();
1177: CHIRP('U');
1178: idtinit();
1179: CHIRP('I');
1180: }
1181:
1182: typedef struct
1183: {
1184: unsigned short off_lo;
1185: unsigned short seg;
1186: unsigned short flags;
1187: unsigned short off_hi;
1188: } IDT;
1189:
1190: /*
1191: * ldtinit()
1192: *
1193: * Fix up descriptors which are hard to create properly at compile/link time.
1194: * Apply to idt and ldt.
1195: *
1196: * Swap 16-bit words at descriptor+2, descriptor+6.
1197: */
1198: void
1199: idtinit()
1200: {
1201: extern IDT idt[], idtend[];
1202: extern IDT ldt[], ldtend[];
1203: extern IDT gdtFixBegin[], gdtFixEnd[];
1204:
1205: register IDT *ip;
1206: register unsigned short tmp;
1207:
1208: for (ip = idt; ip < idtend; ip++) {
1209: tmp = ip->off_hi;
1210: ip->off_hi = ip->seg;
1211: ip->seg = tmp;
1212: }
1213:
1214: for (ip = ldt; ip < ldtend; ip++) {
1215: tmp = ip->off_hi;
1216: ip->off_hi = ip->seg;
1217: ip->seg = tmp;
1218: }
1219:
1220: for (ip = gdtFixBegin; ip < gdtFixEnd; ip++) {
1221: tmp = ip->off_hi;
1222: ip->off_hi = ip->seg;
1223: ip->seg = tmp;
1224: }
1225: }
1226:
1227: void
1228: init_phy_seg(ptable1_v, addr, base)
1229: long *ptable1_v;
1230: {
1231: register int i;
1232:
1233: for (i=0; i<btoc(0x10000); i++) {
1234: ptable1_v[addr+i] = base | SEG_SRW;
1235: base += NBPC;
1236: }
1237: }
1238:
1239: /*
1240: * Load up segmentation registers.
1241: */
1242: SR ugmtab[NUSEG];
1243:
1244: void
1245: segload()
1246: {
1247: register int i;
1248: register SR *start;
1249:
1250: /*
1251: * 1. unprogram the currently active UGM user segments
1252: * reset ugmtab
1253: */
1254: for (start = &ugmtab[1]; start < &ugmtab[NUSEG]; start++) {
1255: if (start->sr_segp)
1256: unload(start);
1257: start->sr_segp = 0;
1258: }
1259:
1260: /*
1261: * 2. Load each segment in the p->p_region list into the MMU
1262: * Remember values in ugmtab.
1263: */
1264: start = &ugmtab[1];
1265: for (i = 1; i < NUSEG; i++) {
1266: if (u.u_segl[i].sr_segp) {
1267: *start = u.u_segl[i];
1268: switch (i) {
1269: case SIPDATA:
1270: if (u.u_segl[SISTACK].sr_base)
1271: start->sr_size = min(start->sr_size,
1272: (long)u.u_segl[SISTACK].sr_base-
1273: u.u_segl[SISTACK].sr_size);
1274: break;
1275: case SISTACK:
1276: start->sr_base -= start->sr_size;
1277: break;
1278: }
1279:
1280: start->sr_segp = 0;
1281: if (SELF->p_segp[i]) {
1282: start->sr_segp = SELF->p_segp[i];
1283: doload(start);
1284: }
1285: start++;
1286: }
1287: }
1288:
1289: /* 3. Update shm segment information. */
1290: shmLoad();
1291: }
1292:
1293: SR *
1294: loaded(pp)
1295: register cseg_t *pp;
1296: {
1297: register SR *start;
1298:
1299: for (start = ugmtab; start < ugmtab + NUSEG; start++) {
1300: if (start->sr_segp && start->sr_segp->s_vmem == pp) {
1301: return start;
1302: }
1303: }
1304: return 0;
1305: }
1306:
1307: MAKESR(r0stk, _r0stk);
1308: extern int tss_sp0;
1309:
1310: /*
1311: * General initialization
1312: */
1313: void
1314: i8086()
1315: {
1316: unsigned csize, isize, ssize, allsize;
1317: caddr_t base;
1318: unsigned int calc_mem, boost;
1319:
1320: /* This is the first C code executed after paging is turned on. */
1321:
1322: workPoolInit();
1323:
1324: /*
1325: * Allocate contiguous physical memory if PHYS_MEM is patched
1326: * to a nonzero value.
1327: */
1328: if (PHYS_MEM) {
1329: physMem.sr_size = (PHYS_MEM+NBPC-1)&~(NBPC-1);
1330: valloc(&physMem);
1331: physMemInit();
1332: }
1333:
1334: /*
1335: * Allocate a click for ring 0 stack.
1336: */
1337: r0stk.sr_size = NBPC;
1338: valloc(&r0stk);
1339: tss_sp0 = r0stk.sr_base + NBPC;
1340:
1341: /*
1342: * calc_mem is used for autosizing buffer cache and kalloc pool.
1343: * It is total_mem, limited below by 1 meg and above by 12 meg.
1344: * The upper limit is a temporary move to allow booting on 16 Meg
1345: * systems.
1346: *
1347: * "boost" is used in autosizing buffer cache and kalloc pool.
1348: * It is the number of megabytes of calc_mem above 1 meg, i.e.,
1349: * a number between 0 and 11.
1350: */
1351: if (total_mem < ONE_MEG)
1352: calc_mem = ONE_MEG;
1353: else if (total_mem > 12 * ONE_MEG)
1354: calc_mem = 12 * ONE_MEG;
1355: else
1356: calc_mem = total_mem;
1357:
1358: boost = (calc_mem - ONE_MEG) / ONE_MEG;
1359:
1360: /*
1361: * If the number of cache buffers was not explicitly set (i.e., !0)
1362: * then calculate the number of buffers using the simple heuristic:
1363: * 128 minimum + 400 per MB of available RAM (i.e., after 1MB)
1364: */
1365: if (NBUF == 0)
1366: NBUF = 128 + (400 * boost);
1367:
1368: /*
1369: * If the amount of kalloc() space was not explicitly set (i.e., !0)
1370: * then calculate using the simple heuristic:
1371: * 64k minimum + 32k per MB of available RAM (i.e., after 1MB)
1372: */
1373: if (ALLSIZE == 0)
1374: ALLSIZE = 65536 + (32768 * boost);
1375:
1376: blockp.sr_size = NBUF*BSIZE;
1377: valloc(&blockp);
1378:
1379: allocp.sr_size= allsize = NBUF*sizeof(BUF) + ALLSIZE;
1380: #if USE_SLOT
1381: allocp.sr_size += ssize = NSLOT * (sizeof(int) + slotsz);
1382: #else
1383: ssize = 0;
1384: #endif
1385: allocp.sr_size += isize = NINODE* sizeof(INODE);
1386: allocp.sr_size += csize = NCLIST* sizeof(CLIST);
1387: valloc(&allocp);
1388: base = allocp.sr_base;
1389: allkp = setarena(base, allsize);
1390: base += allsize;
1391: #if USE_SLOT
1392: slotp = (int *)base;
1393: base += ssize;
1394: #endif
1395: inodep = (INODE*) base;
1396: base += isize;
1397: clistp = (paddr_t)base;
1398: }
1399:
1400: /*
1401: * Allocate srp->sr_size bytes of physical memory, and map it into
1402: * virtual memory space. At the end, the struct at srp will describe
1403: * the new segment.
1404: */
1405: void
1406: valloc(srp)
1407: SR *srp;
1408: {
1409: register int npage;
1410:
1411: /*
1412: * If we've run out of virtual memory space, panic().
1413: *
1414: * A more graceful solution is needed, but valloc() does
1415: * not provide a return value.
1416: */
1417: if (sysmem.vaddre + srp->sr_size > MAX_VADDR) {
1418: panic("valloc: out of virtual memory space");
1419: }
1420:
1421: npage = btoc(srp->sr_size);
1422:
1423: srp->sr_base = sysmem.vaddre;
1424: srp->sr_segp->s_size = srp->sr_size;
1425: srp->sr_segp->s_vmem = c_alloc(npage);
1426: srp->sr_segp->s_flags = SFSYST|SFCORE;
1427: doload(srp);
1428:
1429: sysmem.vaddre += ctob(npage);
1430: }
1431:
1432: /*
1433: * See if the given process may fit in core.
1434: */
1435: int
1436: testcore(pp)
1437: register PROC *pp;
1438: {
1439: return 1;
1440: }
1441:
1442: /*
1443: * Calculate segmentation for a
1444: * new program. If there is a stack segment
1445: * present merge it into the data segment and
1446: * relocate the argument list.
1447: * Make sure that the changes are reflected in the u.u_segl array
1448: * which sproto sets up.
1449: */
1450: int
1451: mproto()
1452: {
1453: return 1;
1454: }
1455:
1456: int
1457: accdata(base, count)
1458: unsigned base, count;
1459: {
1460: SR *srp;
1461:
1462: srp = &u.u_segl[SIPDATA];
1463: return base>=srp->sr_base && base+count <= srp->sr_base+srp->sr_size;
1464: }
1465:
1466: int
1467: accstack(base, count)
1468: unsigned base;
1469: {
1470: SR *srp;
1471:
1472: srp = &u.u_segl[SISTACK];
1473: return base>=srp->sr_base-srp->sr_size && base+count<=srp->sr_base;
1474: }
1475:
1476: int
1477: acctext(base, count)
1478: unsigned base;
1479: {
1480: SR *srp;
1481:
1482: srp = &u.u_segl[SISTEXT];
1483: return base>=srp->sr_base && base+count <= srp->sr_base+srp->sr_size;
1484: }
1485:
1486: printhex(v, max)
1487: unsigned long v;
1488: {
1489: register int i;
1490:
1491: for (i = max-1; i>=0; --i)
1492: putchar(digtab[(v >> (i*4)) & 0xF]);
1493: }
1494:
1495: /* Read a 16 byte number from the CMOS. */
1496: unsigned int
1497: read16_cmos(addr)
1498: unsigned int addr;
1499: {
1500: unsigned char read_cmos();
1501:
1502: return((read_cmos(addr+1)<<8) + read_cmos(addr));
1503: } /* read16_cmos() */
1504:
1505: int
1506: c_grow(sp, new_bytes)
1507: SEG *sp;
1508: int new_bytes;
1509: {
1510: register int i;
1511: register cseg_t *pp;
1512: int new_clicks, pno, nsize, old_clicks;
1513: SR *srp;
1514:
1515: T_PIGGY(0x8000000, printf("c_grow(sp: %x, new: %x)", sp, new_bytes););
1516:
1517: new_clicks = btoc(new_bytes);
1518: old_clicks = btoc(sp->s_size);
1519:
1520: if (new_clicks == old_clicks) {
1521: goto ok_c_grow;
1522: }
1523:
1524: if (new_clicks < old_clicks) {
1525: printf("%s:can't contract segment\n",u.u_comm);
1526: goto no_c_grow;
1527: }
1528:
1529: if (new_clicks - old_clicks > allocno()) {
1530: goto no_c_grow;
1531: }
1532:
1533: T_PIGGY(0x8000000, printf("nc: %x, oc: %x,",new_clicks,old_clicks););
1534:
1535: /*
1536: * Allocate a new descriptor vector if necessary.
1537: * pp is the element corresponding to the virtual address
1538: * "0"(sr_base)
1539: */
1540: pp = sp->s_vmem;
1541: nsize = areasize(new_clicks);
1542: if (nsize != areasize(old_clicks)
1543: && !(pp = (cseg_t*)arealloc(new_clicks))) {
1544: T_PIGGY(0x8000000,
1545: printf("Can not allocate new descriptor."););
1546: goto no_c_grow;
1547: }
1548:
1549: T_PIGGY(0x8000000, printf("new pp: %x", pp););
1550:
1551: if (0 != (srp = loaded(sp->s_vmem))) {
1552: T_PIGGY(0x8000000, printf("unloading srp: %x, ", srp););
1553: unload(srp);
1554: srp->sr_segp = 0;
1555: }
1556:
1557: /*
1558: * Allocate new descriptors.
1559: */
1560: T_PIGGY(0x8000000, printf("new desc: ["););
1561: for (i = old_clicks; i < new_clicks; i++) {
1562: pno = *--sysmem.pfree;
1563: pp[i] = clickseg(pno) | SEG_RW;
1564: T_PIGGY(0x8000000, printf("%x, ", pp[i]););
1565: }
1566: T_PIGGY(0x8000000, printf("]"););
1567:
1568: /*
1569: * Copy unchanged descriptors and free old vector if necessary.
1570: */
1571: if (pp != sp->s_vmem) {
1572: T_PIGGY(0x8000000, printf("old desc: ["););
1573: for (i = 0; i < old_clicks; i++) {
1574: pp[i] = sp->s_vmem[i];
1575: T_PIGGY(0x8000000, printf("%x, ", pp[i]););
1576: }
1577: T_PIGGY(0x8000000, printf("]"););
1578: areafree((BLOCKLIST*)sp->s_vmem, old_clicks);
1579: }
1580:
1581: sp->s_vmem = pp;
1582:
1583: /*
1584: * clear the added clicks
1585: *
1586: * MAPIO macro - convert array of page descriptors, offset
1587: * into system global address.
1588: */
1589: T_PIGGY(0x8000000, printf("dmaclear(%x, %x, 0)",
1590: ctob(new_clicks - old_clicks),
1591: MAPIO(sp->s_vmem, ctob(old_clicks))
1592: );
1593: ); /* T_PIGGY() */
1594:
1595: dmaclear(ctob(new_clicks - old_clicks),
1596: MAPIO(sp->s_vmem, ctob(old_clicks)), 0);
1597:
1598: ok_c_grow:
1599: return 0;
1600:
1601: no_c_grow:
1602: return -1;
1603: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.