1f34c97a297b936b9387fd7f5f2707239f08c551
[people/mcb30/legacybios.git] / src / system.c
1 // 16bit system callbacks
2 //
3 // Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
4 // Copyright (C) 2002  MandrakeSoft S.A.
5 //
6 // This file may be distributed under the terms of the GNU GPLv3 license.
7
8 #include "util.h" // irq_restore
9 #include "biosvar.h" // CONFIG_BIOS_TABLE
10 #include "ioport.h" // inb
11 #include "cmos.h" // inb_cmos
12
13 #define E820_RAM          1
14 #define E820_RESERVED     2
15 #define E820_ACPI         3
16 #define E820_NVS          4
17 #define E820_UNUSABLE     5
18
19 // Use PS2 System Control port A to set A20 enable
20 static inline u8
21 set_a20(u8 cond)
22 {
23     // get current setting first
24     u8 newval, oldval = inb(PORT_A20);
25     if (cond)
26         newval = oldval | 0x02;
27     else
28         newval = oldval & ~0x02;
29     outb(newval, PORT_A20);
30
31     return (newval & 0x02) != 0;
32 }
33
34 static void
35 handle_152400(struct bregs *regs)
36 {
37     set_a20(0);
38     handle_ret(regs, 0);
39 }
40
41 static void
42 handle_152401(struct bregs *regs)
43 {
44     set_a20(1);
45     handle_ret(regs, 0);
46 }
47
48 static void
49 handle_152402(struct bregs *regs)
50 {
51     regs->al = !!(inb(PORT_A20) & 0x20);
52     handle_ret(regs, 0);
53 }
54
55 static void
56 handle_152403(struct bregs *regs)
57 {
58     regs->bx = 3;
59     handle_ret(regs, 0);
60 }
61
62 static void
63 handle_1524XX(struct bregs *regs)
64 {
65     handle_ret(regs, RET_EUNSUPPORTED);
66 }
67
68 static void
69 handle_1524(struct bregs *regs)
70 {
71     switch (regs->al) {
72     case 0x00: handle_152400(regs); break;
73     case 0x01: handle_152401(regs); break;
74     case 0x02: handle_152402(regs); break;
75     case 0x03: handle_152403(regs); break;
76     default:   handle_1524XX(regs); break;
77     }
78 }
79
80 // removable media eject
81 static void
82 handle_1552(struct bregs *regs)
83 {
84     handle_ret(regs, 0);
85 }
86
87 // Wait for CX:DX microseconds. currently using the
88 // refresh request port 0x61 bit4, toggling every 15usec
89 static void
90 handle_1586(struct bregs *regs)
91 {
92     irq_enable();
93     usleep((regs->cx << 16) | regs->dx);
94     irq_disable();
95 }
96
97 static void
98 handle_1587(struct bregs *regs)
99 {
100     // +++ should probably have descriptor checks
101     // +++ should have exception handlers
102
103     u8 prev_a20_enable = set_a20(1); // enable A20 line
104
105     // 128K max of transfer on 386+ ???
106     // source == destination ???
107
108     // ES:SI points to descriptor table
109     // offset   use     initially  comments
110     // ==============================================
111     // 00..07   Unused  zeros      Null descriptor
112     // 08..0f   GDT     zeros      filled in by BIOS
113     // 10..17   source  ssssssss   source of data
114     // 18..1f   dest    dddddddd   destination of data
115     // 20..27   CS      zeros      filled in by BIOS
116     // 28..2f   SS      zeros      filled in by BIOS
117
118     //es:si
119     //eeee0
120     //0ssss
121     //-----
122
123 // check for access rights of source & dest here
124
125     // Initialize GDT descriptor
126     u16 si = regs->si;
127     u16 base15_00 = (regs->es << 4) + si;
128     u16 base23_16 = regs->es >> 12;
129     if (base15_00 < (regs->es<<4))
130         base23_16++;
131     SET_VAR(ES, *(u16*)(si+0x08+0), 47);       // limit 15:00 = 6 * 8bytes/descriptor
132     SET_VAR(ES, *(u16*)(si+0x08+2), base15_00);// base 15:00
133     SET_VAR(ES, *(u8 *)(si+0x08+4), base23_16);// base 23:16
134     SET_VAR(ES, *(u8 *)(si+0x08+5), 0x93);     // access
135     SET_VAR(ES, *(u16*)(si+0x08+6), 0x0000);   // base 31:24/reserved/limit 19:16
136
137     // Initialize CS descriptor
138     SET_VAR(ES, *(u16*)(si+0x20+0), 0xffff);// limit 15:00 = normal 64K limit
139     SET_VAR(ES, *(u16*)(si+0x20+2), 0x0000);// base 15:00
140     SET_VAR(ES, *(u8 *)(si+0x20+4), 0x000f);// base 23:16
141     SET_VAR(ES, *(u8 *)(si+0x20+5), 0x9b);  // access
142     SET_VAR(ES, *(u16*)(si+0x20+6), 0x0000);// base 31:24/reserved/limit 19:16
143
144     // Initialize SS descriptor
145     u16 ss = GET_SEG(SS);
146     base15_00 = ss << 4;
147     base23_16 = ss >> 12;
148     SET_VAR(ES, *(u16*)(si+0x28+0), 0xffff);   // limit 15:00 = normal 64K limit
149     SET_VAR(ES, *(u16*)(si+0x28+2), base15_00);// base 15:00
150     SET_VAR(ES, *(u8 *)(si+0x28+4), base23_16);// base 23:16
151     SET_VAR(ES, *(u8 *)(si+0x28+5), 0x93);     // access
152     SET_VAR(ES, *(u16*)(si+0x28+6), 0x0000);   // base 31:24/reserved/limit 19:16
153
154     asm volatile(
155         // Load new descriptor tables
156         "lgdt %%es:(%1)\n"
157         "lidt %%cs:pmode_IDT_info\n"
158
159         // set PE bit in CR0
160         "movl %%cr0, %%eax\n"
161         "orb $0x01, %%al\n"
162         "movl %%eax, %%cr0\n"
163
164         // far jump to flush CPU queue after transition to protected mode
165         "ljmpw $0x0020, $1f\n"
166         "1:\n"
167
168         // GDT points to valid descriptor table, now load DS, ES
169         "movw $0x10, %%ax\n" // 010 000 = 2nd descriptor in table, TI=GDT, RPL=00
170         "movw %%ax, %%ds\n"
171         "movw $0x18, %%ax\n" // 011 000 = 3rd descriptor in table, TI=GDT, RPL=00
172         "movw %%ax, %%es\n"
173
174         // move CX words from DS:SI to ES:DI
175         "xorw %%si, %%si\n"
176         "xorw %%di, %%di\n"
177         "rep movsw\n"
178
179         // reset PG bit in CR0 ???
180         "movl %%cr0, %%eax\n"
181         "andb $0xfe, %%al\n"
182         "movl %%eax, %%cr0\n"
183
184         // far jump to flush CPU queue after transition to real mode
185         "ljmpw $0xf000, $2f\n"
186         "2:\n"
187
188         // restore IDT to normal real-mode defaults
189         "lidt %%cs:rmode_IDT_info\n"
190
191         // Restore %ds (from %ss)
192         "movw %%ss, %%ax\n"
193         "movw %%ax, %%ds\n"
194         : : "c" (regs->cx), "r" (si + 8)
195         : "eax", "di", "si"); // XXX - also clobbers %es
196
197     set_a20(prev_a20_enable);
198
199     handle_ret(regs, 0);
200 }
201
202 // Get the amount of extended memory (above 1M)
203 static void
204 handle_1588(struct bregs *regs)
205 {
206     regs->al = inb_cmos(CMOS_MEM_EXTMEM_LOW);
207     regs->ah = inb_cmos(CMOS_MEM_EXTMEM_HIGH);
208     // According to Ralf Brown's interrupt the limit should be 15M,
209     // but real machines mostly return max. 63M.
210     if (regs->ax > 0xffc0)
211         regs->ax = 0xffc0;
212     set_cf(regs, 0);
213 }
214
215 // Device busy interrupt.  Called by Int 16h when no key available
216 static void
217 handle_1590(struct bregs *regs)
218 {
219 }
220
221 // Interrupt complete.  Called by Int 16h when key becomes available
222 static void
223 handle_1591(struct bregs *regs)
224 {
225 }
226
227 // keyboard intercept
228 static void
229 handle_154f(struct bregs *regs)
230 {
231     set_cf(regs, 1);
232 }
233
234 static void
235 handle_15c0(struct bregs *regs)
236 {
237     regs->es = SEG_BIOS;
238     regs->bx = (u16)&BIOS_CONFIG_TABLE;
239     handle_ret(regs, 0);
240 }
241
242 static void
243 handle_15c1(struct bregs *regs)
244 {
245     regs->es = GET_BDA(ebda_seg);
246     set_cf(regs, 0);
247 }
248
249 static void
250 handle_15e801(struct bregs *regs)
251 {
252     // my real system sets ax and bx to 0
253     // this is confirmed by Ralph Brown list
254     // but syslinux v1.48 is known to behave
255     // strangely if ax is set to 0
256     // regs.u.r16.ax = 0;
257     // regs.u.r16.bx = 0;
258
259     // Get the amount of extended memory (above 1M)
260     regs->cl = inb_cmos(CMOS_MEM_EXTMEM_LOW);
261     regs->ch = inb_cmos(CMOS_MEM_EXTMEM_HIGH);
262
263     // limit to 15M
264     if (regs->cx > 0x3c00)
265         regs->cx = 0x3c00;
266
267     // Get the amount of extended memory above 16M in 64k blocs
268     regs->dl = inb_cmos(CMOS_MEM_EXTMEM2_LOW);
269     regs->dh = inb_cmos(CMOS_MEM_EXTMEM2_HIGH);
270
271     // Set configured memory equal to extended memory
272     regs->ax = regs->cx;
273     regs->bx = regs->dx;
274
275     set_cf(regs, 0);
276 }
277
278 #define ACPI_DATA_SIZE    0x00010000L
279
280 static void
281 set_e820_range(u16 DI, u32 start, u32 end, u16 type)
282 {
283     SET_VAR(ES, *(u16*)(DI+0), start);
284     SET_VAR(ES, *(u16*)(DI+2), start >> 16);
285     SET_VAR(ES, *(u16*)(DI+4), 0x00);
286     SET_VAR(ES, *(u16*)(DI+6), 0x00);
287
288     end -= start;
289     SET_VAR(ES, *(u16*)(DI+8), end);
290     SET_VAR(ES, *(u16*)(DI+10), end >> 16);
291     SET_VAR(ES, *(u16*)(DI+12), 0x0000);
292     SET_VAR(ES, *(u16*)(DI+14), 0x0000);
293
294     SET_VAR(ES, *(u16*)(DI+16), type);
295     SET_VAR(ES, *(u16*)(DI+18), 0x0);
296 }
297
298 // XXX - should create e820 memory map in post and just copy it here.
299 static void
300 handle_15e820(struct bregs *regs)
301 {
302     if (regs->edx != 0x534D4150) {
303         handle_ret(regs, RET_EUNSUPPORTED);
304         return;
305     }
306
307     u32 extended_memory_size = inb_cmos(CMOS_MEM_EXTMEM2_HIGH);
308     extended_memory_size <<= 8;
309     extended_memory_size |= inb_cmos(CMOS_MEM_EXTMEM2_LOW);
310     extended_memory_size *= 64;
311     // greater than EFF00000???
312     if (extended_memory_size > 0x3bc000)
313         // everything after this is reserved memory until we get to 0x100000000
314         extended_memory_size = 0x3bc000;
315     extended_memory_size *= 1024;
316     extended_memory_size += (16L * 1024 * 1024);
317
318     if (extended_memory_size <= (16L * 1024 * 1024)) {
319         extended_memory_size = inb_cmos(CMOS_MEM_EXTMEM_HIGH);
320         extended_memory_size <<= 8;
321         extended_memory_size |= inb_cmos(CMOS_MEM_EXTMEM_LOW);
322         extended_memory_size *= 1024;
323     }
324
325     switch (regs->bx) {
326     case 0:
327         set_e820_range(regs->di, 0x0000000L, 0x0009fc00L, E820_RAM);
328         regs->ebx = 1;
329         regs->eax = 0x534D4150;
330         regs->ecx = 0x14;
331         set_cf(regs, 0);
332         break;
333     case 1:
334         set_e820_range(regs->di, 0x0009fc00L, 0x000a0000L, E820_RESERVED);
335         regs->ebx = 2;
336         regs->eax = 0x534D4150;
337         regs->ecx = 0x14;
338         set_cf(regs, 0);
339         break;
340     case 2:
341         set_e820_range(regs->di, 0x000e8000L, 0x00100000L, E820_RESERVED);
342         regs->ebx = 3;
343         regs->eax = 0x534D4150;
344         regs->ecx = 0x14;
345         set_cf(regs, 0);
346         break;
347     case 3:
348         set_e820_range(regs->di, 0x00100000L,
349                        extended_memory_size - ACPI_DATA_SIZE, E820_RAM);
350         regs->ebx = 4;
351         regs->eax = 0x534D4150;
352         regs->ecx = 0x14;
353         set_cf(regs, 0);
354         break;
355     case 4:
356         set_e820_range(regs->di,
357                        extended_memory_size - ACPI_DATA_SIZE,
358                        extended_memory_size, E820_ACPI); // ACPI RAM
359         regs->ebx = 5;
360         regs->eax = 0x534D4150;
361         regs->ecx = 0x14;
362         set_cf(regs, 0);
363         break;
364     case 5:
365         /* 256KB BIOS area at the end of 4 GB */
366         set_e820_range(regs->di, 0xfffc0000L, 0x00000000L, E820_RESERVED);
367         regs->ebx = 0;
368         regs->eax = 0x534D4150;
369         regs->ecx = 0x14;
370         set_cf(regs, 0);
371         break;
372     default:  /* AX=E820, DX=534D4150, BX unrecognized */
373         handle_ret(regs, RET_EUNSUPPORTED);
374     }
375 }
376
377 static void
378 handle_15e8XX(struct bregs *regs)
379 {
380     handle_ret(regs, RET_EUNSUPPORTED);
381 }
382
383 static void
384 handle_15e8(struct bregs *regs)
385 {
386     switch (regs->al) {
387     case 0x01: handle_15e801(regs); break;
388     case 0x20: handle_15e820(regs); break;
389     default:   handle_15e8XX(regs); break;
390     }
391 }
392
393 static void
394 handle_15XX(struct bregs *regs)
395 {
396     handle_ret(regs, RET_EUNSUPPORTED);
397 }
398
399 // INT 15h System Services Entry Point
400 void VISIBLE16
401 handle_15(struct bregs *regs)
402 {
403     //debug_enter(regs);
404     switch (regs->ah) {
405     case 0x24: handle_1524(regs); break;
406     case 0x4f: handle_154f(regs); break;
407     case 0x52: handle_1552(regs); break;
408     case 0x53: handle_1553(regs); break;
409     case 0x83: handle_1583(regs); break;
410     case 0x86: handle_1586(regs); break;
411     case 0x87: handle_1587(regs); break;
412     case 0x88: handle_1588(regs); break;
413     case 0x90: handle_1590(regs); break;
414     case 0x91: handle_1591(regs); break;
415     case 0xc0: handle_15c0(regs); break;
416     case 0xc1: handle_15c1(regs); break;
417     case 0xc2: handle_15c2(regs); break;
418     case 0xe8: handle_15e8(regs); break;
419     default:   handle_15XX(regs); break;
420     }
421     //debug_exit(regs);
422 }
423
424 // INT 12h Memory Size Service Entry Point
425 void VISIBLE16
426 handle_12(struct bregs *regs)
427 {
428     debug_enter(regs);
429     regs->ax = GET_BDA(mem_size_kb);
430     debug_exit(regs);
431 }
432
433 // INT 11h Equipment List Service Entry Point
434 void VISIBLE16
435 handle_11(struct bregs *regs)
436 {
437     debug_enter(regs);
438     regs->ax = GET_BDA(equipment_list_flags);
439     debug_exit(regs);
440 }
441
442 // INT 05h Print Screen Service Entry Point
443 void VISIBLE16
444 handle_05(struct bregs *regs)
445 {
446     debug_enter(regs);
447 }
448
449 // INT 10h Video Support Service Entry Point
450 void VISIBLE16
451 handle_10(struct bregs *regs)
452 {
453     debug_enter(regs);
454     // dont do anything, since the VGA BIOS handles int10h requests
455 }
456
457 void VISIBLE16
458 handle_nmi(struct bregs *regs)
459 {
460     debug_isr(regs);
461     // XXX
462 }
463
464 // INT 75 - IRQ13 - MATH COPROCESSOR EXCEPTION
465 void VISIBLE16
466 handle_75(struct bregs *regs)
467 {
468     debug_isr(regs);
469
470     // clear irq13
471     outb(0, PORT_MATH_CLEAR);
472     // clear interrupt
473     eoi_both_pics();
474     // legacy nmi call
475     struct bregs br;
476     memset(&br, 0, sizeof(br));
477     call16_int(0x02, &br);
478 }