Limit cdrom emulation available functions.
[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     set_code_success(regs);
39 }
40
41 static void
42 handle_152401(struct bregs *regs)
43 {
44     set_a20(1);
45     set_code_success(regs);
46 }
47
48 static void
49 handle_152402(struct bregs *regs)
50 {
51     regs->al = !!(inb(PORT_A20) & 0x20);
52     set_code_success(regs);
53 }
54
55 static void
56 handle_152403(struct bregs *regs)
57 {
58     regs->bx = 3;
59     set_code_success(regs);
60 }
61
62 static void
63 handle_1524XX(struct bregs *regs)
64 {
65     set_code_fail(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     set_code_success(regs);
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     SET_SEG(ES, regs->es);
127     u16 si = regs->si;
128     u16 base15_00 = (regs->es << 4) + si;
129     u16 base23_16 = regs->es >> 12;
130     if (base15_00 < (u16)(regs->es<<4))
131         base23_16++;
132     SET_VAR(ES, *(u16*)(si+0x08+0), 47);       // limit 15:00 = 6 * 8bytes/descriptor
133     SET_VAR(ES, *(u16*)(si+0x08+2), base15_00);// base 15:00
134     SET_VAR(ES, *(u8 *)(si+0x08+4), base23_16);// base 23:16
135     SET_VAR(ES, *(u8 *)(si+0x08+5), 0x93);     // access
136     SET_VAR(ES, *(u16*)(si+0x08+6), 0x0000);   // base 31:24/reserved/limit 19:16
137
138     // Initialize CS descriptor
139     SET_VAR(ES, *(u16*)(si+0x20+0), 0xffff);// limit 15:00 = normal 64K limit
140     SET_VAR(ES, *(u16*)(si+0x20+2), 0x0000);// base 15:00
141     SET_VAR(ES, *(u8 *)(si+0x20+4), 0x000f);// base 23:16
142     SET_VAR(ES, *(u8 *)(si+0x20+5), 0x9b);  // access
143     SET_VAR(ES, *(u16*)(si+0x20+6), 0x0000);// base 31:24/reserved/limit 19:16
144
145     // Initialize SS descriptor
146     u16 ss = GET_SEG(SS);
147     base15_00 = ss << 4;
148     base23_16 = ss >> 12;
149     SET_VAR(ES, *(u16*)(si+0x28+0), 0xffff);   // limit 15:00 = normal 64K limit
150     SET_VAR(ES, *(u16*)(si+0x28+2), base15_00);// base 15:00
151     SET_VAR(ES, *(u8 *)(si+0x28+4), base23_16);// base 23:16
152     SET_VAR(ES, *(u8 *)(si+0x28+5), 0x93);     // access
153     SET_VAR(ES, *(u16*)(si+0x28+6), 0x0000);   // base 31:24/reserved/limit 19:16
154
155     u16 count = regs->cx;
156     asm volatile(
157         // Load new descriptor tables
158         "lgdtw %%es:0x8(%%si)\n"
159         "lidtw %%cs:pmode_IDT_info\n"
160
161         // set PE bit in CR0
162         "movl %%cr0, %%eax\n"
163         "orb $0x01, %%al\n"
164         "movl %%eax, %%cr0\n"
165
166         // far jump to flush CPU queue after transition to protected mode
167         "ljmpw $0x0020, $1f\n"
168         "1:\n"
169
170         // GDT points to valid descriptor table, now load DS, ES
171         "movw $0x10, %%ax\n" // 010 000 = 2nd descriptor in table, TI=GDT, RPL=00
172         "movw %%ax, %%ds\n"
173         "movw $0x18, %%ax\n" // 011 000 = 3rd descriptor in table, TI=GDT, RPL=00
174         "movw %%ax, %%es\n"
175
176         // move CX words from DS:SI to ES:DI
177         "xorw %%si, %%si\n"
178         "xorw %%di, %%di\n"
179         "rep movsw\n"
180
181         // reset PG bit in CR0 ???
182         "movl %%cr0, %%eax\n"
183         "andb $0xfe, %%al\n"
184         "movl %%eax, %%cr0\n"
185
186         // far jump to flush CPU queue after transition to real mode
187         "ljmpw $0xf000, $2f\n"
188         "2:\n"
189
190         // restore IDT to normal real-mode defaults
191         "lidt %%cs:rmode_IDT_info\n"
192
193         // Restore %ds (from %ss)
194         "movw %%ss, %%ax\n"
195         "movw %%ax, %%ds\n"
196         : "+c"(count), "+S"(si)
197         : : "eax", "di", "cc"); // XXX - also clobbers %es
198
199     set_a20(prev_a20_enable);
200
201     set_code_success(regs);
202 }
203
204 // Get the amount of extended memory (above 1M)
205 static void
206 handle_1588(struct bregs *regs)
207 {
208     regs->al = inb_cmos(CMOS_MEM_EXTMEM_LOW);
209     regs->ah = inb_cmos(CMOS_MEM_EXTMEM_HIGH);
210     // According to Ralf Brown's interrupt the limit should be 15M,
211     // but real machines mostly return max. 63M.
212     if (regs->ax > 0xffc0)
213         regs->ax = 0xffc0;
214     set_success(regs);
215 }
216
217 // Device busy interrupt.  Called by Int 16h when no key available
218 static void
219 handle_1590(struct bregs *regs)
220 {
221 }
222
223 // Interrupt complete.  Called by Int 16h when key becomes available
224 static void
225 handle_1591(struct bregs *regs)
226 {
227 }
228
229 // keyboard intercept
230 static void
231 handle_154f(struct bregs *regs)
232 {
233     // set_fail(regs);  -- don't report this failure.
234     set_cf(regs, 1);
235 }
236
237 static void
238 handle_15c0(struct bregs *regs)
239 {
240     regs->es = SEG_BIOS;
241     regs->bx = (u16)&BIOS_CONFIG_TABLE;
242     set_code_success(regs);
243 }
244
245 static void
246 handle_15c1(struct bregs *regs)
247 {
248     regs->es = GET_BDA(ebda_seg);
249     set_success(regs);
250 }
251
252 static void
253 handle_15e801(struct bregs *regs)
254 {
255     // my real system sets ax and bx to 0
256     // this is confirmed by Ralph Brown list
257     // but syslinux v1.48 is known to behave
258     // strangely if ax is set to 0
259     // regs.u.r16.ax = 0;
260     // regs.u.r16.bx = 0;
261
262     // Get the amount of extended memory (above 1M)
263     regs->cl = inb_cmos(CMOS_MEM_EXTMEM_LOW);
264     regs->ch = inb_cmos(CMOS_MEM_EXTMEM_HIGH);
265
266     // limit to 15M
267     if (regs->cx > 0x3c00)
268         regs->cx = 0x3c00;
269
270     // Get the amount of extended memory above 16M in 64k blocs
271     regs->dl = inb_cmos(CMOS_MEM_EXTMEM2_LOW);
272     regs->dh = inb_cmos(CMOS_MEM_EXTMEM2_HIGH);
273
274     // Set configured memory equal to extended memory
275     regs->ax = regs->cx;
276     regs->bx = regs->dx;
277
278     set_success(regs);
279 }
280
281 #define ACPI_DATA_SIZE    0x00010000L
282
283 static void
284 set_e820_range(struct bregs *regs, u32 start, u32 end, u16 type, int last)
285 {
286     SET_FARVAR(regs->es, *(u16*)(regs->di+0), start);
287     SET_FARVAR(regs->es, *(u16*)(regs->di+2), start >> 16);
288     SET_FARVAR(regs->es, *(u16*)(regs->di+4), 0x00);
289     SET_FARVAR(regs->es, *(u16*)(regs->di+6), 0x00);
290
291     end -= start;
292     SET_FARVAR(regs->es, *(u16*)(regs->di+8), end);
293     SET_FARVAR(regs->es, *(u16*)(regs->di+10), end >> 16);
294     SET_FARVAR(regs->es, *(u16*)(regs->di+12), 0x0000);
295     SET_FARVAR(regs->es, *(u16*)(regs->di+14), 0x0000);
296
297     SET_FARVAR(regs->es, *(u16*)(regs->di+16), type);
298     SET_FARVAR(regs->es, *(u16*)(regs->di+18), 0x0);
299
300     if (last)
301         regs->ebx = 0;
302     else
303         regs->ebx++;
304     regs->eax = 0x534D4150;
305     regs->ecx = 0x14;
306     set_success(regs);
307 }
308
309 // XXX - should create e820 memory map in post and just copy it here.
310 static void
311 handle_15e820(struct bregs *regs)
312 {
313     if (regs->edx != 0x534D4150) {
314         set_code_fail(regs, RET_EUNSUPPORTED);
315         return;
316     }
317
318     u32 extended_memory_size = inb_cmos(CMOS_MEM_EXTMEM2_HIGH);
319     extended_memory_size <<= 8;
320     extended_memory_size |= inb_cmos(CMOS_MEM_EXTMEM2_LOW);
321     extended_memory_size *= 64;
322     // greater than EFF00000???
323     if (extended_memory_size > 0x3bc000)
324         // everything after this is reserved memory until we get to 0x100000000
325         extended_memory_size = 0x3bc000;
326     extended_memory_size *= 1024;
327     extended_memory_size += (16L * 1024 * 1024);
328
329     if (extended_memory_size <= (16L * 1024 * 1024)) {
330         extended_memory_size = inb_cmos(CMOS_MEM_EXTMEM_HIGH);
331         extended_memory_size <<= 8;
332         extended_memory_size |= inb_cmos(CMOS_MEM_EXTMEM_LOW);
333         extended_memory_size *= 1024;
334     }
335
336     switch (regs->bx) {
337     case 0:
338         set_e820_range(regs, 0x0000000L, 0x0009fc00L, E820_RAM, 0);
339         break;
340     case 1:
341         set_e820_range(regs, 0x0009fc00L, 0x000a0000L, E820_RESERVED, 0);
342         break;
343     case 2:
344         set_e820_range(regs, 0x000e8000L, 0x00100000L, E820_RESERVED, 0);
345         break;
346     case 3:
347         set_e820_range(regs, 0x00100000L,
348                        extended_memory_size - ACPI_DATA_SIZE, E820_RAM, 0);
349         break;
350     case 4:
351         set_e820_range(regs,
352                        extended_memory_size - ACPI_DATA_SIZE,
353                        extended_memory_size, E820_ACPI, 0);
354         break;
355     case 5:
356         /* 256KB BIOS area at the end of 4 GB */
357         set_e820_range(regs, 0xfffc0000L, 0x00000000L, E820_RESERVED, 1);
358         break;
359     default:  /* AX=E820, DX=534D4150, BX unrecognized */
360         set_code_fail(regs, RET_EUNSUPPORTED);
361     }
362 }
363
364 static void
365 handle_15e8XX(struct bregs *regs)
366 {
367     set_code_fail(regs, RET_EUNSUPPORTED);
368 }
369
370 static void
371 handle_15e8(struct bregs *regs)
372 {
373     switch (regs->al) {
374     case 0x01: handle_15e801(regs); break;
375     case 0x20: handle_15e820(regs); break;
376     default:   handle_15e8XX(regs); break;
377     }
378 }
379
380 static void
381 handle_15XX(struct bregs *regs)
382 {
383     set_code_fail(regs, RET_EUNSUPPORTED);
384 }
385
386 // INT 15h System Services Entry Point
387 void VISIBLE16
388 handle_15(struct bregs *regs)
389 {
390     //debug_enter(regs);
391     switch (regs->ah) {
392     case 0x24: handle_1524(regs); break;
393     case 0x4f: handle_154f(regs); break;
394     case 0x52: handle_1552(regs); break;
395     case 0x53: handle_1553(regs); break;
396     case 0x83: handle_1583(regs); break;
397     case 0x86: handle_1586(regs); break;
398     case 0x87: handle_1587(regs); break;
399     case 0x88: handle_1588(regs); break;
400     case 0x90: handle_1590(regs); break;
401     case 0x91: handle_1591(regs); break;
402     case 0xc0: handle_15c0(regs); break;
403     case 0xc1: handle_15c1(regs); break;
404     case 0xc2: handle_15c2(regs); break;
405     case 0xe8: handle_15e8(regs); break;
406     default:   handle_15XX(regs); break;
407     }
408 }
409
410 // INT 12h Memory Size Service Entry Point
411 void VISIBLE16
412 handle_12(struct bregs *regs)
413 {
414     debug_enter(regs);
415     regs->ax = GET_BDA(mem_size_kb);
416 }
417
418 // INT 11h Equipment List Service Entry Point
419 void VISIBLE16
420 handle_11(struct bregs *regs)
421 {
422     debug_enter(regs);
423     regs->ax = GET_BDA(equipment_list_flags);
424 }
425
426 // INT 05h Print Screen Service Entry Point
427 void VISIBLE16
428 handle_05(struct bregs *regs)
429 {
430     debug_enter(regs);
431 }
432
433 // INT 10h Video Support Service Entry Point
434 void VISIBLE16
435 handle_10(struct bregs *regs)
436 {
437     debug_enter(regs);
438     // dont do anything, since the VGA BIOS handles int10h requests
439 }
440
441 void VISIBLE16
442 handle_nmi()
443 {
444     debug_isr();
445     BX_PANIC("NMI Handler called\n");
446 }
447
448 // INT 75 - IRQ13 - MATH COPROCESSOR EXCEPTION
449 void VISIBLE16
450 handle_75()
451 {
452     debug_isr();
453
454     // clear irq13
455     outb(0, PORT_MATH_CLEAR);
456     // clear interrupt
457     eoi_both_pics();
458     // legacy nmi call
459     struct bregs br;
460     memset(&br, 0, sizeof(br));
461     call16_int(0x02, &br);
462 }