![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i16_vcpi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / dos / i16|
Return to i16_vcpi.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / dos / i16 |
1.1 root 1: /*
2: * Copyright (c) 1995-1994 The University of Utah and
3: * the Computer Systems Laboratory at the University of Utah (CSL).
4: * All rights reserved.
5: *
6: * Permission to use, copy, modify and distribute this software is hereby
7: * granted provided that (1) source code retains these copyright, permission,
8: * and disclaimer notices, and (2) redistributions including binaries
9: * reproduce the notices in supporting documentation, and (3) all advertising
10: * materials mentioning features or use of this software display the following
11: * acknowledgement: ``This product includes software developed by the
12: * Computer Systems Laboratory at the University of Utah.''
13: *
14: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
15: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
16: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17: *
18: * CSL requests users of this software to return to [email protected] any
19: * improvements that they make and grant CSL redistribution rights.
20: *
21: * Author: Bryan Ford, University of Utah CSL
22: */
23:
24: #include <mach/boolean.h>
25: #include <mach/vm_param.h>
26: #include <mach/machine/code16.h>
27: #include <mach/machine/vm_types.h>
28: #include <mach/machine/paging.h>
29: #include <mach/machine/eflags.h>
30: #include <mach/machine/proc_reg.h>
31: #include <mach/machine/far_ptr.h>
32: #include <mach/machine/vcpi.h>
33: #include <mach/machine/asm.h>
34:
35: #include "config.h"
36: #include "i16.h"
37: #include "i16_dos.h"
38: #include "cpu.h"
39: #include "real.h"
40: #include "debug.h"
41: #include "vm_param.h"
42:
43: #ifdef ENABLE_VCPI
44:
45: static boolean_t ems_page_allocated;
46: static unsigned short ems_handle;
47:
48: static vm_offset_t vcpi_pdir, vcpi_ptable0;
49:
50: struct far_pointer_32 vcpi_pmode_entry = {0, VCPI_CS};
51: struct vcpi_switch_data vcpi_switch_data;
52:
53: static struct pseudo_descriptor gdt_pdesc, idt_pdesc;
54:
55: static boolean_t pic_reprogrammed;
56:
57: /* Save area for the DOS interrupt vectors
58: that used to be in the place we relocated the master PIC to. */
59: static struct far_pointer_16 master_save_vecs[8];
60:
61:
62: #ifdef ENABLE_PAGING
63: #define VCPI_PAGING_INIT(pdir_pa, first_unmapped_pa) vcpi_paging_init(pdir_pa, first_unmapped_pa)
64: #else
65: #define VCPI_PAGING_INIT(pdir_pa, first_unmapped_pa) ((void)0)
66: #endif
67:
68: #ifdef ENABLE_KERNEL_LDT
69: #define KERNEL_LDT_INIT() (vcpi_switch_data.ldt_sel = KERNEL_LDT)
70: #else
71: #define KERNEL_LDT_INIT() ((void)0)
72: #endif
73:
74:
75: CODE16
76:
77: static void i16_vcpi_switch_to_pmode()
78: {
79: extern vm_offset_t boot_image_pa;
80:
81: i16_cli();
82:
83: i16_assert(i16_get_ds() == i16_get_cs());
84: i16_assert(i16_get_es() == i16_get_cs());
85: i16_assert(i16_get_ss() == i16_get_cs());
86:
87: /* Make sure the TSS isn't marked busy. */
88: cpu[0].tables.gdt[KERNEL_TSS_IDX].access &= ~ACC_TSS_BUSY;
89:
90: /* Ask the VCPI server to switch to protected mode. */
91: asm volatile("
92: movl %%esp,%%edx
93: int $0x67
94: "SEXT(pmode_return)":
95: movl %%edx,%%esp
96: movw %2,%%dx
97: movw %%dx,%%ss
98: movw %%dx,%%ds
99: movw %%dx,%%es
100: xorw %%dx,%%dx
101: movw %%dx,%%fs
102: movw %%dx,%%gs
103: " :
104: : "a" ((unsigned short)0xde0c),
105: "S" (boot_image_pa + (vm_offset_t)&vcpi_switch_data),
106: "i" (KERNEL_DS)
107: : "eax", "edx", "esi");
108:
109: /* Make sure the direction flag is still clear. */
110: i16_cld();
111: }
112:
113: static void i16_vcpi_switch_to_real_mode()
114: {
115: i16_cli();
116:
117: /* As requested by VCPI spec... */
118: i16_clts();
119:
120: /* Perform the switch. */
121: asm volatile("
122: movl %%esp,%%edx
123: pushl %1
124: pushl %1
125: pushl %1
126: pushl %1
127: pushl %1
128: pushl %%edx
129: pushl $0
130: pushl %1
131: pushl $1f
132: movw %2,%%ds
133: lcall %%ss:"SEXT(vcpi_pmode_entry)"
134: 1:
135: " :
136: : "a" ((unsigned short)0xde0c),
137: "r" ((unsigned)real_cs),
138: "r" ((unsigned short)LINEAR_DS)
139: : "eax", "edx");
140:
141: i16_assert(!(i16_get_eflags() & EFL_IF));
142: i16_assert(i16_get_ds() == i16_get_cs());
143: i16_assert(i16_get_es() == i16_get_cs());
144: i16_assert(i16_get_ss() == i16_get_cs());
145:
146: /* Make sure the direction flag is still clear. */
147: i16_cld();
148: }
149:
150: CODE32
151:
152: static void vcpi_real_int(int intnum, struct real_call_data *rcd)
153: {
154: do_16bit(
155: unsigned int eflags;
156:
157: i16_vcpi_switch_to_real_mode();
158: i16_real_int(intnum, rcd);
159: i16_vcpi_switch_to_pmode();
160: );
161: }
162:
163: static void vcpi_exit(int rc)
164: {
165: do_16bit(
166: i16_vcpi_switch_to_real_mode();
167: i16_exit(rc);
168: while (1);
169: );
170: }
171:
172: CODE16
173:
174: static inline void
175: i16_vcpi_set_int_vecs(unsigned short master, unsigned short slave)
176: {
177: unsigned short rc;
178:
179: i16_assert(!(get_eflags() & EFL_IF));
180: asm volatile("int $0x67"
181: : "=a" (rc)
182: : "a" ((unsigned short)0xde0b),
183: "b" ((unsigned short)master),
184: "c" ((unsigned short)slave));
185: i16_assert((rc & 0xff00) == 0);
186: i16_assert(!(get_eflags() & EFL_IF));
187: }
188:
189: /* Find a (hopefully) empty set of interrupt vectors
190: to use for the master hardware interrupts.
191: We assume that eight interrupt vectors in a row
192: that all have the same value are unused.
193: If VCPI servers weren't so brain-damaged
194: and took care of this during interrupt reflection
195: (like we do when running in raw mode),
196: this kludgery wouldn't be needed... */
197: static int i16_find_free_vec_range()
198: {
199: /* i will track the first vector in a range;
200: j will track the last. */
201: int i, j;
202: struct far_pointer_16 iv, jv;
203:
204: j = 0xff;
205: i16_dos_get_int_vec(j, &jv);
206:
207: for (i = j-1; ; i--)
208: {
209: if (i == 0x50)
210: {
211: /* No completely free sets found.
212: Stop here and just use 0x50-0x57. */
213: break;
214: }
215:
216: i16_dos_get_int_vec(i, &iv);
217: if ((iv.ofs != jv.ofs) || (iv.seg != jv.seg))
218: {
219: /* Vector contents changed. */
220: j = i;
221: jv = iv;
222: continue;
223: }
224:
225: if ((j-i+1 >= 8) && ((i & 7) == 0))
226: {
227: /* Found a free range. */
228: break;
229: }
230: }
231:
232: return i;
233: }
234:
235: void i16_vcpi_check()
236: {
237: extern vm_offset_t dos_mem_phys_free_mem;
238: extern vm_offset_t dos_mem_phys_free_size;
239: extern void pmode_return();
240: extern vm_offset_t boot_image_pa;
241: extern void (*i16_switch_to_real_mode)();
242: extern void (*i16_switch_to_pmode)();
243:
244: unsigned short rc;
245: unsigned short first_free_pte;
246: unsigned short vcpi_ver;
247:
248: i16_assert(boot_image_pa == kvtophys(0));
249:
250: /* Check for presence of EMM driver. */
251: {
252: int dev_info, out_status;
253: int fh;
254:
255: fh = i16_dos_open("EMMXXXX0", 0);
256: if (fh < 0)
257: return;
258: dev_info = i16_dos_get_device_info(fh);
259: out_status = i16_dos_get_output_status(fh);
260: i16_dos_close(fh);
261: if ((dev_info < 0) || !(dev_info & 0x80)
262: || (out_status != 0xff))
263: return;
264: }
265:
266: /* Allocate an EMS page to force the EMM to be turned on.
267: If it fails, keep going anyway -
268: it may simply mean all the EMS pages are allocated. */
269: asm volatile("int $0x67"
270: : "=a" (rc),
271: "=d" (ems_handle)
272: : "a" ((unsigned short)0x4300),
273: "b" ((unsigned short)1));
274: if (!(rc & 0xff00))
275: ems_page_allocated = TRUE;
276:
277: /* Check for VCPI. */
278: asm volatile("int $0x67" : "=a" (rc), "=b" (vcpi_ver) : "a" ((unsigned short)0xde00));
279: if (rc & 0xff00)
280: return;
281: i16_assert(vcpi_ver >= 0x0100);
282:
283: /* OK, it's there - we're now committed to using VCPI. */
284: i16_switch_to_real_mode = i16_vcpi_switch_to_real_mode;
285: i16_switch_to_pmode = i16_vcpi_switch_to_pmode;
286: real_int = vcpi_real_int;
287: real_exit = vcpi_exit;
288:
289: do_debug(i16_puts("VCPI detected"));
290:
291: /* Allocate a page directory and page table from low DOS memory. */
292: {
293: vm_offset_t new_dos_mem;
294:
295: new_dos_mem = ((dos_mem_phys_free_mem + PAGE_MASK) & ~PAGE_MASK)
296: + PAGE_SIZE*2;
297: if ((!dos_mem_phys_free_mem)
298: || (new_dos_mem - dos_mem_phys_free_mem
299: > dos_mem_phys_free_size))
300: i16_die("not enough low DOS memory available");
301: dos_mem_phys_free_size -= new_dos_mem - dos_mem_phys_free_mem;
302: dos_mem_phys_free_mem = new_dos_mem;
303: vcpi_pdir = new_dos_mem - PAGE_SIZE*2;
304: vcpi_ptable0 = vcpi_pdir + PAGE_SIZE;
305: }
306:
307: /* Initialize them. */
308: {
309: int i;
310: pt_entry_t pde0 = vcpi_ptable0
311: | INTEL_PTE_VALID | INTEL_PTE_WRITE | INTEL_PTE_USER;
312:
313: set_fs(vcpi_pdir >> 4);
314: asm volatile("movl %0,%%fs:(0)" : : "r" (pde0));
315: for (i = 1; i < NPDES + NPTES; i++)
316: asm volatile("movl $0,%%fs:(,%0,4)" : : "r" (i));
317: }
318:
319: /* Initialize the protected-mode interface. */
320: asm volatile("
321: pushw %%es
322: movw %4,%%es
323: int $0x67
324: popw %%es
325: "
326: : "=a" (rc),
327: "=b" (vcpi_pmode_entry.ofs),
328: "=D" (first_free_pte)
329: : "a" ((unsigned short)0xde01),
330: "r" ((unsigned short)(vcpi_ptable0 >> 4)),
331: "D" (0),
332: "S" (&cpu[0].tables.gdt[VCPI_CS_IDX]));
333: i16_assert((rc & 0xff00) == 0);
334: i16_assert(get_ds() == get_cs());
335: i16_assert(get_es() == get_cs());
336:
337: #ifdef DEBUG
338: /* Sanity check: make sure the server did what it was supposed to do. */
339:
340: i16_assert((cpu[0].tables.gdt[VCPI_CS_IDX].access & ACC_P|ACC_CODE) == ACC_P|ACC_CODE);
341: if (cpu[0].tables.gdt[VCPI_CS_IDX].granularity & SZ_G)
342: i16_assert(vcpi_pmode_entry.ofs <
343: (((vm_offset_t)cpu[0].tables.gdt[VCPI_CS_IDX].limit_high << 28)
344: | ((vm_offset_t)cpu[0].tables.gdt[VCPI_CS_IDX].limit_low << 12)
345: | (vm_offset_t)0xfff));
346: else
347: i16_assert(vcpi_pmode_entry.ofs <
348: (((vm_offset_t)cpu[0].tables.gdt[VCPI_CS_IDX].limit_high << 16)
349: | (vm_offset_t)cpu[0].tables.gdt[VCPI_CS_IDX].limit_low));
350:
351: i16_assert(first_free_pte/sizeof(pt_entry_t) >= 1*1024*1024/PAGE_SIZE);
352: i16_assert(first_free_pte/sizeof(pt_entry_t) <= 4*1024*1024/PAGE_SIZE);
353:
354: {
355: int i;
356:
357: for (i = 0; i < 1*1024*1024/PAGE_SIZE; i++)
358: {
359: pt_entry_t entry;
360:
361: set_ds(vcpi_ptable0 >> 4);
362: entry = ((pt_entry_t*)0)[i];
363: set_ds(get_cs());
364: i16_assert(entry & INTEL_PTE_VALID);
365: if (i < 0xf0000/PAGE_SIZE)
366: i16_assert(entry & INTEL_PTE_WRITE);
367: i16_assert(entry & INTEL_PTE_USER);
368: i16_assert(!(entry & INTEL_PTE_AVAIL));
369: }
370: }
371: #endif /* DEBUG */
372:
373: /* Find the VCPI server's hardware interrupt vector mappings. */
374: asm volatile("int $0x67"
375: : "=a" (rc),
376: "=b" (irq_master_base),
377: "=c" (irq_slave_base)
378: : "a" ((unsigned short)0xde0a));
379: i16_assert((rc & 0xff00) == 0);
380: irq_master_base &= 0xffff;
381: irq_slave_base &= 0xffff;
382: i16_assert((irq_master_base & 7) == 0);
383: i16_assert((irq_master_base == 0x08) || (irq_master_base >= 0x20));
384: i16_assert((irq_slave_base & 7) == 0);
385: i16_assert(irq_slave_base >= 0x20);
386:
387: /* If they're the usual DOS values, change them. */
388: if (irq_master_base == 0x08)
389: {
390: pic_reprogrammed = TRUE;
391:
392: i16_cli();
393:
394: irq_master_base = i16_find_free_vec_range();
395:
396: /* Save the old vectors in that range
397: and set them to a copy of vectors 8-15. */
398: {
399: int i;
400:
401: for (i = 0; i < 8; i++)
402: {
403: struct far_pointer_16 hw_vec;
404:
405: i16_dos_get_int_vec(irq_master_base+i,
406: &master_save_vecs[i]);
407: i16_dos_get_int_vec(0x08+i, &hw_vec);
408: i16_dos_set_int_vec(irq_master_base+i, &hw_vec);
409: }
410: }
411:
412: /* Reprogram the PIC. */
413: i16_pic_set_master(irq_master_base);
414:
415: /* Inform the VCPI server. */
416: i16_vcpi_set_int_vecs(irq_master_base, irq_slave_base);
417: }
418:
419: /* Initialize the switch-to-pmode data structure. */
420: vcpi_switch_data.phys_pdir = vcpi_pdir;
421: vcpi_switch_data.lin_gdt = boot_image_pa+(vm_offset_t)&gdt_pdesc.limit;
422: vcpi_switch_data.lin_idt = boot_image_pa+(vm_offset_t)&idt_pdesc.limit;
423: vcpi_switch_data.tss_sel = KERNEL_TSS;
424: vcpi_switch_data.entry_eip = (unsigned short)(vm_offset_t)&pmode_return;
425: vcpi_switch_data.entry_cs = KERNEL_16_CS;
426:
427: /* Initialize the GDT and IDT pseudo-descriptors. */
428: gdt_pdesc.limit = sizeof(cpu[0].tables.gdt)-1;
429: gdt_pdesc.linear_base = boot_image_pa + (vm_offset_t)&cpu[0].tables.gdt;
430: idt_pdesc.limit = sizeof(cpu[0].tables.idt)-1;
431: idt_pdesc.linear_base = boot_image_pa + (vm_offset_t)&cpu[0].tables.idt;
432:
433: /* Set the GDT to temporary settings
434: just for getting into pmode the first time. */
435: i16_gdt_init_temp();
436:
437: /* VCPI insists on loading a TSS immediately on entering pmode,
438: so initialize the KERNEL_TSS descriptor in the GDT. */
439: i16_fill_gdt_descriptor(&cpu[0], KERNEL_TSS,
440: boot_image_pa + (vm_offset_t)&cpu[0].tables.tss,
441: sizeof(cpu[0].tables.tss)-1,
442: ACC_PL_K|ACC_TSS, 0);
443: cpu[0].tables.tss.io_bit_map_offset = sizeof(cpu[0].tables.tss);
444:
445: #if 0
446: /* Dump the various VCPI data structures, for debugging. */
447: {
448: int i;
449:
450: i16_puts("Switch data");
451: i16_writehexl(switch_data.phys_pdir); i16_putchar(' ');
452: i16_writehexl(switch_data.lin_gdt); i16_putchar(' ');
453: i16_writehexl(switch_data.lin_idt); i16_putchar(' ');
454: i16_writehexw(switch_data.ldt_sel); i16_putchar(' ');
455: i16_writehexw(switch_data.tss_sel); i16_putchar(' ');
456: i16_writehexl(switch_data.entry_eip); i16_putchar(' ');
457: i16_writehexw(switch_data.entry_cs); i16_puts("");
458:
459: i16_puts("GDT pdesc");
460: i16_writehexw(gdt_pdesc.limit); i16_putchar(' ');
461: i16_writehexl(gdt_pdesc.linear_base); i16_puts("");
462:
463: i16_puts("IDT pdesc");
464: i16_writehexw(idt_pdesc.limit); i16_putchar(' ');
465: i16_writehexl(idt_pdesc.linear_base); i16_puts("");
466:
467: i16_puts("GDT");
468: for (i = 0; i < GDTSZ; i++)
469: {
470: i16_writehexw(i*8); i16_putchar(' ');
471: i16_writehexll(*((long long*)&cpu[0].tables.gdt[i]));
472: i16_puts("");
473: }
474: }
475: #endif
476:
477: /* Switch into pmode briefly to initialize the CPU tables and such. */
478: i16_vcpi_switch_to_pmode();
479: i16_do_32bit(
480:
481: /* Note that right now we can only access the first 1MB of memory,
482: because paging is enabled and that's the only memory region that's been mapped.
483: The rest of physical memory won't be mapped until VCPI_PAGING_INIT,
484: but VCPI_PAGING_INIT requires allocating memory for page tables,
485: and we can't call phys_mem_collect() to provide memory to the allocator
486: until all physical memory can be read and written.
487: To get out of this catch-22,
488: we call dos_mem_collect() beforehand here
489: to make low DOS memory available for allocation by VCPI_PAGING_INIT.
490: The call to phys_mem_collect() later will cause dos_mem_collect
491: to be called a second time, but it'll just do nothing then. */
492: dos_mem_collect();
493:
494: /* Initialize the basic CPU tables. */
495: cpu_init(&cpu[0]);
496:
497: /* Initialize the paging system. */
498: VCPI_PAGING_INIT(vcpi_pdir, (vm_offset_t)first_free_pte / 4 * PAGE_SIZE);
499:
500: /* Now that we can access all physical memory,
501: collect the remaining memory regions we discovered while in 16-bit mode
502: and add them to our free memory list. */
503: phys_mem_collect();
504:
505: /* Initialize the hardware interrupt vectors in the IDT. */
506: idt_irq_init();
507:
508: /* Now that we have an initialized LDT descriptor, start using it. */
509: KERNEL_LDT_INIT();
510:
511: /* Switch to real mode and back again once more,
512: to make sure everything's loaded properly. */
513: do_16bit(
514: i16_vcpi_switch_to_real_mode();
515: i16_vcpi_switch_to_pmode();
516: );
517:
518: vcpi_start();
519: );
520: }
521:
522: /* Shouldn't be necessary, but just in case the end of the above function,
523: containing the .code16, gets "optimized away"... */
524: CODE16
525:
526: void i16_vcpi_shutdown()
527: {
528: if (pic_reprogrammed)
529: {
530: pic_reprogrammed = FALSE;
531:
532: i16_cli();
533:
534: i16_assert(irq_master_base >= 0x20);
535:
536: /* Reprogram the PIC. */
537: i16_pic_set_master(0x08);
538:
539: /* Inform the VCPI server. */
540: i16_vcpi_set_int_vecs(0x08, irq_slave_base);
541:
542: /* Restore the old interrupt vectors. */
543: {
544: int i;
545:
546: for (i = 0; i < 8; i++)
547: {
548: i16_dos_set_int_vec(irq_master_base+i,
549: &master_save_vecs[i]);
550: }
551: }
552:
553: i16_sti();
554: }
555:
556: if (ems_page_allocated)
557: {
558: ems_page_allocated = 0;
559: asm volatile("int $0x67" : : "a" (0x4500), "d" (ems_handle));
560: }
561: }
562:
563: #endif ENABLE_VCPI
564:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.