![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun-mmu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / machine / sun|
Return to sun-mmu.c CVS log | Up to [The Machine Emulator] / tme / machine / sun |
1.1 root 1: /* $Id: sun-mmu.c,v 1.4 2003/05/16 21:48:13 fredette Exp $ */
2:
3: /* machine/sun/sun-mmu.c - classic Sun MMU emulation implementation: */
4:
5: /*
6: * Copyright (c) 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: sun-mmu.c,v 1.4 2003/05/16 21:48:13 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/machine/sun.h>
41:
42: /* macros: */
43: #define TME_SUN_MMU_PMEG_TLBS (16)
44:
45: /* structures: */
46:
47: /* an allocated TLB set in a classic two-level Sun MMU: */
48: struct tme_sun_mmu_tlb_set {
49:
50: /* the next allocated TLB set: */
51: struct tme_sun_mmu_tlb_set *tme_sun_mmu_tlb_set_next;
52:
53: /* the user's pointer into the TLB set: */
54: TME_ATOMIC_POINTER_TYPE(struct tme_bus_tlb **) tme_sun_mmu_tlb_set_pointer;
55:
56: /* the base of this TLB set: */
57: struct tme_bus_tlb *tme_sun_mmu_tlb_set_base;
58:
59: /* the size of one TLB entry: */
60: unsigned int tme_sun_mmu_tlb_set_sizeof_one;
61:
62: /* the number of TLB entries per context in the set: */
63: unsigned int tme_sun_mmu_tlb_set_count;
64: };
65:
66: /* one PMEG in a classic two-level Sun MMU: */
67: struct tme_sun_mmu_pmeg {
68:
69: /* the current list of TLBs using a page table entry in this PMEG, and
70: the head within that list: */
71: struct tme_bus_tlb *tme_sun_mmu_pmeg_tlbs[TME_SUN_MMU_PMEG_TLBS];
72: unsigned int tme_sun_mmu_pmeg_tlbs_head;
73: };
74:
75: /* the private structure for a classic two-level Sun MMU: */
76: struct tme_sun_mmu {
77:
78: /* the information provided by the user: */
79: struct tme_sun_mmu_info tme_sun_mmu_info;
80: #define tme_sun_mmu_element tme_sun_mmu_info.tme_sun_mmu_info_element
81: #define tme_sun_mmu_address_bits tme_sun_mmu_info.tme_sun_mmu_info_address_bits
82: #define tme_sun_mmu_pgoffset_bits tme_sun_mmu_info.tme_sun_mmu_info_pgoffset_bits
83: #define tme_sun_mmu_pteindex_bits tme_sun_mmu_info.tme_sun_mmu_info_pteindex_bits
84: #define tme_sun_mmu_contexts tme_sun_mmu_info.tme_sun_mmu_info_contexts
85: #define tme_sun_mmu_pmegs_count tme_sun_mmu_info.tme_sun_mmu_info_pmegs
86: #define tme_sun_mmu_seginv tme_sun_mmu_info.tme_sun_mmu_info_seginv
87: #define _tme_sun_mmu_tlb_fill_private tme_sun_mmu_info.tme_sun_mmu_info_tlb_fill_private
88: #define _tme_sun_mmu_tlb_fill tme_sun_mmu_info.tme_sun_mmu_info_tlb_fill
89:
90: /* the number of bits in a segment map index: */
91: tme_uint8_t tme_sun_mmu_segment_bits;
92:
93: /* the segment map: */
94: unsigned short *tme_sun_mmu_segment_map;
95:
96: /* the PMEGs: */
97: struct tme_sun_mmu_pmeg *tme_sun_mmu_pmegs;
98:
99: /* the PTEs: */
100: struct tme_sun_mmu_pte *tme_sun_mmu_ptes;
101:
102: /* the allocated TLB sets: */
103: struct tme_sun_mmu_tlb_set *tme_sun_mmu_tlb_sets;
104: };
105:
106: /* this creates a classic two-level Sun MMU: */
107: void *
108: tme_sun_mmu_new(struct tme_sun_mmu_info *info)
109: {
110: struct tme_sun_mmu *mmu;
111: unsigned int segmap_count;
112: unsigned int segmap_i;
113:
114: /* allocate the new private structure: */
115: mmu = tme_new0(struct tme_sun_mmu, 1);
116:
117: /* copy the user-provided information: */
118: mmu->tme_sun_mmu_info = *info;
119:
120: /* allocate the segment map and initialize it to all invalid: */
121: mmu->tme_sun_mmu_segment_bits = (mmu->tme_sun_mmu_address_bits
122: - (mmu->tme_sun_mmu_pteindex_bits
123: + mmu->tme_sun_mmu_pgoffset_bits));
124: segmap_count = (mmu->tme_sun_mmu_contexts
125: * (1 << mmu->tme_sun_mmu_segment_bits));
126: mmu->tme_sun_mmu_segment_map = tme_new(unsigned short, segmap_count);
127: for (segmap_i = 0; segmap_i < segmap_count; segmap_i++) {
128: mmu->tme_sun_mmu_segment_map[segmap_i] = mmu->tme_sun_mmu_seginv;
129: }
130:
131: /* allocate the PMEGs: */
132: mmu->tme_sun_mmu_pmegs = tme_new0(struct tme_sun_mmu_pmeg, mmu->tme_sun_mmu_pmegs_count);
133:
134: /* allocate the PTEs: */
135: mmu->tme_sun_mmu_ptes =
136: tme_new0(struct tme_sun_mmu_pte,
137: mmu->tme_sun_mmu_pmegs_count
138: * (1 << mmu->tme_sun_mmu_pteindex_bits));
139:
140: /* done: */
141: return (mmu);
142: }
143:
144: /* given a context and an address, returns the segment map index and
145: PTE: */
146: static unsigned short
147: _tme_sun_mmu_lookup(struct tme_sun_mmu *mmu, tme_uint8_t context, tme_uint32_t address,
148: struct tme_sun_mmu_pte **_pte)
149: {
150: unsigned short pteindex;
151: unsigned short segment;
152: unsigned short segment_map_index;
153: unsigned short pmeg;
154:
155: /* lose the page offset bits: */
156: address >>= mmu->tme_sun_mmu_pgoffset_bits;
157:
158: /* get the PTE index: */
159: pteindex = (address
160: & (TME_BIT(mmu->tme_sun_mmu_pteindex_bits) - 1));
161: address >>= mmu->tme_sun_mmu_pteindex_bits;
162:
163: /* get the segment number: */
164: segment = (address
165: & (TME_BIT(mmu->tme_sun_mmu_segment_bits) - 1));
166:
167: /* get the segment map index: */
168: segment_map_index = ((context << mmu->tme_sun_mmu_segment_bits)
169: | segment);
170:
171: /* get the PMEG: */
172: pmeg = mmu->tme_sun_mmu_segment_map[segment_map_index];
173:
174: /* return the segment map index and the PTE: */
175: *_pte = (mmu->tme_sun_mmu_ptes + (pmeg << mmu->tme_sun_mmu_pteindex_bits) + pteindex);
176: return (segment_map_index);
177: }
178:
179: /* this invalidates all TLB entries that may be affected by changes to
180: a PMEG: */
181: static void
182: _tme_sun_mmu_pmeg_invalidate(struct tme_sun_mmu *mmu, unsigned short segment_map_index)
183: {
184: struct tme_sun_mmu_pmeg *pmeg;
185: int tlb_i;
186: struct tme_bus_tlb *tlb;
187:
188: /* get the PMEG: */
189: pmeg = mmu->tme_sun_mmu_pmegs + mmu->tme_sun_mmu_segment_map[segment_map_index];
190:
191: /* invalidate all of the TLBs: */
192: for (tlb_i = 0; tlb_i < TME_SUN_MMU_PMEG_TLBS; tlb_i++) {
193: tlb = pmeg->tme_sun_mmu_pmeg_tlbs[tlb_i];
194: pmeg->tme_sun_mmu_pmeg_tlbs[tlb_i] = NULL;
195: if (tlb != NULL) {
196: tme_bus_tlb_invalidate(tlb);
197: }
198: }
199: }
200:
201: /* this gets a PTE: */
202: int
203: tme_sun_mmu_pte_get(void *_mmu, tme_uint8_t context, tme_uint32_t address,
204: struct tme_sun_mmu_pte *_pte)
205: {
206: struct tme_sun_mmu *mmu;
207: unsigned short segment_map_index;
208: struct tme_sun_mmu_pte *pte;
209:
210: /* lookup this address: */
211: mmu = (struct tme_sun_mmu *) _mmu;
212: segment_map_index = _tme_sun_mmu_lookup(mmu, context, address, &pte);
213:
214: #if 0
215: /* if this segment is invalid, return failure: */
216: if (mmu->tme_sun_mmu_segment_map[segment_map_index]
217: == mmu->tme_sun_mmu_seginv) {
218: return (ENOENT);
219: }
220: #endif
221:
222: /* otherwise, copy the PTE: */
223: *_pte = *pte;
224: return (TME_OK);
225: }
226:
227: /* this sets a PTE: */
228: int
229: tme_sun_mmu_pte_set(void *_mmu, tme_uint8_t context, tme_uint32_t address,
230: struct tme_sun_mmu_pte *_pte)
231: {
232: struct tme_sun_mmu *mmu;
233: unsigned short segment_map_index;
234: struct tme_sun_mmu_pte *pte;
235:
236: /* lookup this address: */
237: mmu = (struct tme_sun_mmu *) _mmu;
238: segment_map_index = _tme_sun_mmu_lookup(mmu, context, address, &pte);
239:
240: #if 0
241: /* if this segment is invalid, return failure: */
242: if (mmu->tme_sun_mmu_segment_map[segment_map_index]
243: == mmu->tme_sun_mmu_seginv) {
244: return (ENOENT);
245: }
246: #endif
247:
248: /* invalidate all TLB entries that are affected by changes to this PMEG: */
249: _tme_sun_mmu_pmeg_invalidate(mmu, segment_map_index);
250:
251: /* otherwise, copy the PTE: */
252: *pte = *_pte;
253: return (TME_OK);
254: }
255:
256: /* this gets a segment map entry: */
257: unsigned short
258: tme_sun_mmu_segmap_get(void *_mmu, tme_uint8_t context, tme_uint32_t address)
259: {
260: struct tme_sun_mmu *mmu;
261: struct tme_sun_mmu_pte *pte;
262: unsigned short segment_map_index, pmeg;
263:
264: /* lookup this address: */
265: mmu = (struct tme_sun_mmu *) _mmu;
266: segment_map_index = _tme_sun_mmu_lookup(mmu, context, address, &pte);
267: pmeg = mmu->tme_sun_mmu_segment_map[segment_map_index];
268: tme_log(&mmu->tme_sun_mmu_element->tme_element_log_handle, 1000, TME_OK,
269: (&mmu->tme_sun_mmu_element->tme_element_log_handle,
270: "segmap_get: SEGMAP[%d:0x%08x] -> 0x%04x",
271: context,
272: address,
273: pmeg));
274: return (pmeg);
275: }
276:
277: /* this sets a segment map entry: */
278: void
279: tme_sun_mmu_segmap_set(void *_mmu, tme_uint8_t context, tme_uint32_t address, unsigned short pmeg)
280: {
281: struct tme_sun_mmu *mmu;
282: unsigned short segment_map_index;
283: struct tme_sun_mmu_pte *pte;
284:
285: /* lookup this address: */
286: mmu = (struct tme_sun_mmu *) _mmu;
287: segment_map_index = _tme_sun_mmu_lookup(mmu, context, address, &pte);
288:
289: /* if the old segment is valid, invalidate all TLB entries that
290: are affected by changes to this PMEG - losing a spot in the
291: segment map counts as such a change: */
292: if (
293: #if 0
294: mmu->tme_sun_mmu_segment_map[segment_map_index]
295: != mmu->tme_sun_mmu_seginv
296: #else
297: TRUE
298: #endif
299: ) {
300: _tme_sun_mmu_pmeg_invalidate(mmu, segment_map_index);
301: }
302:
303: /* set the new segment: */
304: mmu->tme_sun_mmu_segment_map[segment_map_index] = pmeg;
305: tme_log(&mmu->tme_sun_mmu_element->tme_element_log_handle, 1000, TME_OK,
306: (&mmu->tme_sun_mmu_element->tme_element_log_handle,
307: "segmap_set: SEGMAP[%d:0x%08x] <- 0x%04x",
308: context,
309: address,
310: pmeg));
311: }
312:
313: /* this fills a TLB entry: */
314: unsigned short
315: tme_sun_mmu_tlb_fill(void *_mmu, struct tme_bus_tlb *tlb,
316: tme_uint8_t context, tme_uint32_t address, unsigned short access)
317: {
318: struct tme_sun_mmu *mmu;
319: unsigned short segment_map_index;
320: struct tme_sun_mmu_pte *pte;
321: tme_bus_addr_t addr_first, addr_last;
322: unsigned short protection, protection_other, tlb_valid_for;
323: tme_uint32_t physical_address;
324: struct tme_sun_mmu_pmeg *pmeg;
325: struct tme_bus_tlb tlb_virtual, *tlb_old;
326: int tlb_i;
327:
328: /* the access must be a read or write by the system or user: */
329: assert(access != 0
330: && (access == TME_SUN_MMU_PTE_PROT_SYSTEM(TME_SUN_MMU_PTE_PROT_RO)
331: || access == TME_SUN_MMU_PTE_PROT_SYSTEM(TME_SUN_MMU_PTE_PROT_RW)
332: || access == TME_SUN_MMU_PTE_PROT_USER(TME_SUN_MMU_PTE_PROT_RO)
333: || access == TME_SUN_MMU_PTE_PROT_USER(TME_SUN_MMU_PTE_PROT_RW)));
334:
335: /* lookup this address: */
336: mmu = (struct tme_sun_mmu *) _mmu;
337: segment_map_index = _tme_sun_mmu_lookup(mmu, context, address, &pte);
338: addr_first = (address & ~(TME_BIT(mmu->tme_sun_mmu_pgoffset_bits) - 1));
339: addr_last = (address | (TME_BIT(mmu->tme_sun_mmu_pgoffset_bits) - 1));
340:
341: /* remember this TLB entry in the PMEG: */
342: pmeg = mmu->tme_sun_mmu_pmegs + mmu->tme_sun_mmu_segment_map[segment_map_index];
343: tlb_i = pmeg->tme_sun_mmu_pmeg_tlbs_head;
344: tlb_old = pmeg->tme_sun_mmu_pmeg_tlbs[tlb_i];
345: if (tlb_old != NULL) {
346: tme_bus_tlb_invalidate(tlb_old);
347: }
348: pmeg->tme_sun_mmu_pmeg_tlbs[tlb_i] = tlb;
349: pmeg->tme_sun_mmu_pmeg_tlbs_head = (tlb_i + 1) & (TME_SUN_MMU_PMEG_TLBS - 1);
350:
351: /* if this page is invalid, return the page-invalid cycle handler,
352: which is valid for reading and writing for the user and system: */
353: if (!(pte->tme_sun_mmu_pte_flags & TME_SUN_MMU_PTE_VALID)) {
354: tme_bus_tlb_initialize(tlb);
355: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first, addr_first);
356: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last, addr_last);
357: tlb->tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ | TME_BUS_CYCLE_WRITE;
358: tlb->tme_bus_tlb_cycle_private = mmu->tme_sun_mmu_info.tme_sun_mmu_info_invalid_private;
359: tlb->tme_bus_tlb_cycle = mmu->tme_sun_mmu_info.tme_sun_mmu_info_invalid;
360: return (TME_SUN_MMU_TLB_SYSTEM | TME_SUN_MMU_TLB_USER);
361: }
362:
363: /* otherwise, this page is valid. get the relevant part of the
364: protection for this accessor (system or user), the part of the
365: protection covering the other accessor (system or user), adjust
366: "access" to be an unshifted TME_SUN_MMU_PTE_PROT_ value, and get
367: the accessor (user or system) that this TLB entry will definitely
368: be valid for: */
369: protection = pte->tme_sun_mmu_pte_flags;
370: if (access & TME_SUN_MMU_PTE_PROT_SYSTEM(TME_SUN_MMU_PTE_PROT_MASK)) {
371: protection_other = protection / TME_SUN_MMU_PTE_PROT_USER(1);
372: access /= TME_SUN_MMU_PTE_PROT_SYSTEM(1);
373: protection /= TME_SUN_MMU_PTE_PROT_SYSTEM(1);
374: tlb_valid_for = TME_SUN_MMU_TLB_SYSTEM;
375: }
376: else {
377: protection_other = protection / TME_SUN_MMU_PTE_PROT_SYSTEM(1);
378: access /= TME_SUN_MMU_PTE_PROT_USER(1);
379: protection /= TME_SUN_MMU_PTE_PROT_USER(1);
380: tlb_valid_for = TME_SUN_MMU_TLB_USER;
381: }
382:
383: /* NB that the following code assumes a particular ordering of
384: TME_SUN_MMU_PTE_PROT_ values. specifically, it assumes that
385: ABORT < ERROR < RO < RW: */
386:
387: /* if the part of the protection covering the other accessor (system
388: or user) allows at least as much access as the relevant part of
389: the protection, this TLB entry will be valid for that other
390: successor as well. we rely on particular definitions of the
391: TME_SUN_MMU_TLB_ macros to make this fast: */
392: #if (3 - TME_SUN_MMU_TLB_SYSTEM) != TME_SUN_MMU_TLB_USER
393: #error "TME_SUN_MMU_TLB_USER and TME_SUN_MMU_TLB_SYSTEM are incompatible"
394: #endif
395: protection &= TME_SUN_MMU_PTE_PROT_MASK;
396: protection_other &= TME_SUN_MMU_PTE_PROT_MASK;
397: if (protection_other >= protection) {
398: tlb_valid_for |= (3 - tlb_valid_for);
399: }
400:
401: /* if the access is protected, return the protection-error cycle
402: handler: */
403: if (protection < access) {
404: if (protection == TME_SUN_MMU_PTE_PROT_ABORT) {
405: abort();
406: }
407: tme_bus_tlb_initialize(tlb);
408: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first, addr_first);
409: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last, addr_last);
410: tlb->tme_bus_tlb_cycles_ok = (TME_BUS_CYCLE_WRITE
411: | (protection == TME_SUN_MMU_PTE_PROT_ERROR
412: ? TME_BUS_CYCLE_READ
413: : 0));
414: tlb->tme_bus_tlb_cycle_private = mmu->tme_sun_mmu_info.tme_sun_mmu_info_proterr_private;
415: tlb->tme_bus_tlb_cycle = mmu->tme_sun_mmu_info.tme_sun_mmu_info_proterr;
416: return (tlb_valid_for);
417: }
418:
419: /* this access is OK. fill the TLB with physical bus information.
420: we pass in the virtual address as the initial physical address
421: because sometimes the virtual part of the address can influence
422: the physical address (as in the Sun-2 PROM mapping): */
423: physical_address = address;
424: (*mmu->_tme_sun_mmu_tlb_fill)
425: (mmu->_tme_sun_mmu_tlb_fill_private,
426: tlb,
427: pte,
428: &physical_address,
429: ((access == TME_SUN_MMU_PTE_PROT_RW)
430: ? TME_BUS_CYCLE_WRITE
431: : TME_BUS_CYCLE_READ));
432:
433: /* create the mapping TLB entry, and update the PTE flags: */
434: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb_virtual.tme_bus_tlb_addr_first, addr_first);
435: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb_virtual.tme_bus_tlb_addr_last, addr_last);
436: pte->tme_sun_mmu_pte_flags |= TME_SUN_MMU_PTE_REF;
437: tlb_virtual.tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ;
438: if (access == TME_SUN_MMU_PTE_PROT_RW) {
439: pte->tme_sun_mmu_pte_flags |= TME_SUN_MMU_PTE_MOD;
440: }
441: if (pte->tme_sun_mmu_pte_flags & TME_SUN_MMU_PTE_MOD) {
442: tlb_virtual.tme_bus_tlb_cycles_ok |= TME_BUS_CYCLE_WRITE;
443: }
444:
445: /* map the filled TLB entry: */
446: tme_bus_tlb_map(tlb, physical_address, &tlb_virtual, address);
447:
448: /* return who this TLB entry is good for: */
449: return (tlb_valid_for);
450: }
451:
452: /* this invalidates all TLB entries in all TLB sets: */
453: void
454: tme_sun_mmu_tlbs_invalidate(void *_mmu)
455: {
456: struct tme_sun_mmu *mmu;
457: struct tme_sun_mmu_tlb_set *tlb_set;
458: struct tme_bus_tlb *tlb;
459: unsigned long tlb_i;
460:
461: /* recover our MMU: */
462: mmu = (struct tme_sun_mmu *) _mmu;
463:
464: /* invalidate all TLB entries in all sets: */
465: for (tlb_set = mmu->tme_sun_mmu_tlb_sets;
466: tlb_set != NULL;
467: tlb_set = tlb_set->tme_sun_mmu_tlb_set_next) {
468: tlb = tlb_set->tme_sun_mmu_tlb_set_base;
469: tlb_i = ((unsigned long) tlb_set->tme_sun_mmu_tlb_set_count) * mmu->tme_sun_mmu_contexts;
470: for (; tlb_i-- > 0; ) {
471: tme_bus_tlb_invalidate(tlb);
472: tlb = (struct tme_bus_tlb *) (((tme_uint8_t *) tlb) + tlb_set->tme_sun_mmu_tlb_set_sizeof_one);
473: }
474: }
475: }
476:
477: /* this sets the user context register: */
478: void
479: tme_sun_mmu_tlbs_context_set(void *_mmu, tme_uint8_t context)
480: {
481: struct tme_sun_mmu *mmu;
482: struct tme_sun_mmu_tlb_set *tlb_set;
483:
484: /* recover our MMU: */
485: mmu = (struct tme_sun_mmu *) _mmu;
486:
487: /* we have to update each TLB set to reflect the context change: */
488: for (tlb_set = mmu->tme_sun_mmu_tlb_sets;
489: tlb_set != NULL;
490: tlb_set = tlb_set->tme_sun_mmu_tlb_set_next) {
491: TME_ATOMIC_WRITE(struct tme_bus_tlb *,
492: *tlb_set->tme_sun_mmu_tlb_set_pointer,
493: (struct tme_bus_tlb *)
494: (((tme_uint8_t *) tlb_set->tme_sun_mmu_tlb_set_base)
495: + (((unsigned long) tlb_set->tme_sun_mmu_tlb_set_count)
496: * tlb_set->tme_sun_mmu_tlb_set_sizeof_one
497: * context)));
498: }
499: }
500:
501: /* this allocates a new TLB set: */
502: int
503: tme_sun_mmu_tlb_set_allocate(void *_mmu,
504: unsigned int count, unsigned int sizeof_one,
505: TME_ATOMIC_POINTER_TYPE(struct tme_bus_tlb **) _tlbs)
506: {
507: struct tme_sun_mmu *mmu;
508: struct tme_bus_tlb *tlbs, *tlb;
509: unsigned long tlb_i;
510: struct tme_sun_mmu_tlb_set *tlb_set;
511:
512: /* recover our mmu: */
513: mmu = (struct tme_sun_mmu *) _mmu;
514:
515: /* allocate and initialize a set of TLBs: */
516: tlb_i = ((unsigned long) mmu->tme_sun_mmu_contexts) * count;
517: tlbs = (struct tme_bus_tlb *) tme_malloc(tlb_i * sizeof_one);
518: tlb = tlbs;
519: for (; tlb_i-- > 0; ) {
520: tme_bus_tlb_invalidate(tlb);
521: tlb = (struct tme_bus_tlb *) (((tme_uint8_t *) tlb) + sizeof_one);
522: }
523:
524: /* remember this set: */
525: tlb_set = tme_new0(struct tme_sun_mmu_tlb_set, 1);
526: tlb_set->tme_sun_mmu_tlb_set_next = mmu->tme_sun_mmu_tlb_sets;
527: tlb_set->tme_sun_mmu_tlb_set_pointer = _tlbs;
528: tlb_set->tme_sun_mmu_tlb_set_base = tlbs;
529: tlb_set->tme_sun_mmu_tlb_set_sizeof_one = sizeof_one;
530: tlb_set->tme_sun_mmu_tlb_set_count = count;
531: mmu->tme_sun_mmu_tlb_sets = tlb_set;
532:
533: TME_ATOMIC_WRITE(struct tme_bus_tlb *, *_tlbs, tlbs);
534: return (TME_OK);
535: }
536:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.