Chameleon

Chameleon Svn Source Tree

Root/branches/ErmaC/Trunk/i386/libsaio/biosfn.c

1/*␊
2 * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights␊
7 * Reserved. This file contains Original Code and/or Modifications of␊
8 * Original Code as defined in and that are subject to the Apple Public␊
9 * Source License Version 2.0 (the "License"). You may not use this file␊
10 * except in compliance with the License. Please obtain a copy of the␊
11 * License at http://www.apple.com/publicsource and read it before using␊
12 * this file.␊
13 * ␊
14 * The Original Code and all software distributed under the License are␊
15 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the␊
19 * License for the specific language governing rights and limitations␊
20 * under the License.␊
21 * ␊
22 * @APPLE_LICENSE_HEADER_END@␊
23 */␊
24/*␊
25 * Copyright 1993 NeXT Computer, Inc.␊
26 * All rights reserved.␊
27 */␊
28␊
29/* Copyright 2007 David Elliott␊
30 2007-12-30 dfe␊
31 - Enhanced code to normalize segment/offset to huge pointers so that any␊
32 linear address within the first MB of memory can be passed to BIOS␊
33 functions. This allows some of the __DATA sections to span into the␊
34 next segment and also allows stack variables to be used whereas the␊
35 old code could only operate on static data in the first 64k.␊
36 NOTE: Requires bios.s change to respect DS.␊
37 */␊
38/* Copyright 2007 VMware Inc.␊
39 2007-12-29 dfe␊
40 - Added ebiosEjectMedia␊
41 */␊
42␊
43#include "bootstruct.h"␊
44#include "libsaio.h"␊
45␊
46␊
47#define MAX_DRIVES 8␊
48␊
49static biosBuf_t bb;␊
50␊
51␊
52//==============================================================================␊
53␊
54int bgetc(void)␊
55{␊
56␉/* Poll for the next character. Most real BIOS do not need this as the␊
57␉ INT 16h,AH=0h function will block until one is received.␊
58␉ Unfortunately, Apple's EFI CSM will never wake up. This idea is lifted␊
59␉ from the grub-a20.patch to GRUB's stage2/asm.S file.␊
60␉*/␊
61␉while(!readKeyboardStatus());␊
62␊
63␉bb.intno = 0x16;␊
64␉bb.eax.r.h = 0x00;␊
65␉bios(&bb);␊
66␊
67␉return bb.eax.rr;␊
68}␊
69␊
70␊
71//==============================================================================␊
72␊
73int readKeyboardStatus(void)␊
74{␊
75␉bb.intno = 0x16;␊
76␉bb.eax.r.h = 0x01;␊
77␉bios(&bb);␊
78␊
79␉if (bb.flags.zf)␊
80␉{␊
81␉␉return 0;␊
82␉}␊
83␉else␊
84␉{␊
85␉␉return bb.eax.rr;␊
86␉}␊
87}␊
88␊
89int readKeyboardShiftFlags(void)␊
90{␊
91␉bb.intno = 0x16;␊
92␉bb.eax.r.h = 0x02;␊
93␉bios(&bb);␊
94␉return bb.eax.r.l;␊
95}␊
96␊
97␊
98//==============================================================================␊
99␊
100unsigned int time18(void)␊
101{␊
102␉union␊
103␉{␊
104␉␉struct␊
105␉␉{␊
106␉␉␉unsigned int low:16;␊
107␉␉␉unsigned int high:16;␊
108␉␉} s;␊
109␊
110␉␉unsigned int i;␊
111␉} time;␊
112 ␊
113␉bb.intno = 0x1a;␊
114␉bb.eax.r.h = 0x00;␊
115␉bios(&bb);␊
116␉time.s.low = bb.edx.rr;␊
117␉time.s.high = bb.ecx.rr;␊
118␊
119␉return time.i;␊
120}␊
121␊
122#if 0␊
123static unsigned long rerangeMemoryMap(unsigned long count)␊
124{␊
125␉int i, still_changing, newcount = count;␊
126␊
127␉MemoryRange * range = (MemoryRange *)BIOS_ADDR;␊
128␉struct MemoryRange change_tmp;␊
129␊
130␉/* sort map list by memory addresses (low -> high) */␊
131␉still_changing = 1;␊
132␉while (still_changing) {␊
133␉␉still_changing = 0;␊
134␉␉for (i=1; i<count; i++) {␊
135␉␉␉/* if <current_addr> > <last_addr>, swap */␊
136␉␉␉if (range[i].base < range[i-1].base) {␊
137␉␉␉␉change_tmp.base = range[i].base;␊
138␉␉␉␉change_tmp.length = range[i].length;␊
139␉␉␉␉change_tmp.type = range[i].type;␊
140␊
141␉␉␉␉range[i].base = range[i-1].base;␊
142␉␉␉␉range[i].length = range[i-1].length;␊
143␉␉␉␉range[i].type = range[i-1].type;␊
144␊
145␉␉␉␉range[i-1].base = change_tmp.base;␊
146␉␉␉␉range[i-1].length = change_tmp.length;␊
147␉␉␉␉range[i-1].type = change_tmp.type;␊
148␊
149␉␉␉␉still_changing=1;␊
150␉␉␉}␊
151␉␉}␊
152␉}␊
153␊
154␉/* clear overlaps */␊
155␉/* linux's arch/i386/kern/setup.c may have better algorithm */␊
156␉for (i=1; i<count; i++) {␊
157␉␉if ( range[i-1].base + range[i-1].length > range[i].base ) {␊
158␉␉␉range[newcount].base = range[i].base + range[i].length;␊
159␉␉␉range[newcount].length = range[i-1].base + range[i-1].length - range[newcount].base;␊
160␉␉␉range[newcount].type = range[i-1].type;␊
161␉␉␉newcount++;␊
162␊
163␉␉␉range[i-1].length = range[i].base - range[i-1].base;␊
164␉␉}␊
165␉}␊
166␊
167␉/*␊
168␉ * 0xb0000000 : 0x10000000 NG␊
169␉ * 0xc0000400 NG␊
170␉ * 0xf2000000 NG␊
171␉ */␊
172␉range[newcount].base = 0xb0000000;␊
173␉range[newcount].length = 0x0f000000;␊
174␉range[newcount].type = kMemoryRangeUsable;␊
175␉newcount++;␊
176␊
177␉return newcount;␊
178}␊
179#endif␊
180␊
181unsigned long getMemoryMap( MemoryRange * rangeArray,␊
182 unsigned long maxRangeCount,␊
183 unsigned long * conMemSizePtr,␊
184 unsigned long * extMemSizePtr )␊
185{␊
186␉#define kMemoryMapSignature 'SMAP'␊
187␉#define kDescriptorSizeMin 20␊
188␊
189␉MemoryRange *␉range = (MemoryRange *)BIOS_ADDR;␊
190␉unsigned long␉count = 0;␊
191␉// unsigned long␉rerangedCount;␊
192␉unsigned long long␉conMemSize = 0;␊
193␉unsigned long long␉extMemSize = 0;␊
194␊
195␉// Prepare for the INT15 E820h call. Each call returns a single␊
196␉// memory range. A continuation value is returned that must be␊
197␉// provided on a subsequent call to fetch the next range.␊
198␉//␊
199␉// Certain BIOSes (Award 6.00PG) expect the upper word in EAX␊
200␉// to be cleared on entry, otherwise only a single range will␊
201␉// be reported.␊
202␉//␊
203␉// Some BIOSes will simply ignore the value of ECX on entry.␊
204␉// Probably best to keep its value at 20 to avoid surprises.␊
205␊
206␉//printf("Get memory map 0x%x, %d\n", rangeArray); getchar();␊
207␉if (maxRangeCount > (BIOS_LEN / sizeof(MemoryRange)))␊
208␉{␊
209␉␉maxRangeCount = (BIOS_LEN / sizeof(MemoryRange));␊
210␉}␊
211␉bb.ebx.rx = 0; // Initial continuation value must be zero.␊
212␊
213␉while (count < maxRangeCount)␊
214␉{␊
215␉␉bb.intno = 0x15;␊
216␉␉bb.eax.rx = 0xe820;␊
217␉␉bb.ecx.rx = kDescriptorSizeMin;␊
218␉␉bb.edx.rx = kMemoryMapSignature;␊
219␉␉bb.edi.rr = NORMALIZED_OFFSET( (unsigned long) range );␊
220␉␉bb.es = NORMALIZED_SEGMENT( (unsigned long) range );␊
221␉␉bios(&bb);␊
222␊
223␉␉// Check for errors.␊
224␊
225␉␉if ( bb.flags.cf || bb.eax.rx != kMemoryMapSignature || bb.ecx.rx != kDescriptorSizeMin )␊
226␉␉{␊
227␉␉//printf("Got an error %x %x %x\n", bb.flags.cf,␊
228␉␉// bb.eax.rx, bb.ecx.rx);␊
229␉␉break;␊
230␉␉}␊
231␊
232␉␉// Tally up the conventional/extended memory sizes.␊
233␊
234␉␉if (range->type == kMemoryRangeUsable || range->type == kMemoryRangeACPI || range->type == kMemoryRangeNVS )␊
235␉␉{␊
236␉␉␉// Tally the conventional memory ranges.␊
237␉␉␉if (range->base + range->length <= 0xa0000)␊
238␉␉␉{␊
239␉␉␉␉conMemSize += range->length;␊
240␉␉␉}␊
241␊
242␉␉␉// Record the top of extended memory.␊
243␉␉␉if (range->base >= EXTENDED_ADDR)␊
244␉␉␉{␊
245␉␉␉␉extMemSize += range->length;␊
246␉␉␉}␊
247␉␉}␊
248␊
249␉␉range++;␊
250␉␉count++;␊
251␊
252␉␉// Is this the last address range?␊
253␊
254␉␉if ( bb.ebx.rx == 0 )␊
255␉␉{␊
256␉␉␉//printf("last range\n");␊
257␉␉␉break;␊
258␉␉}␊
259␉}␊
260␉*conMemSizePtr = conMemSize / 1024; // size in KB␊
261␉*extMemSizePtr = extMemSize / 1024; // size in KB␊
262␊
263#if 0␊
264␉rerangedCount = rerangeMemoryMap(count);␊
265␉range += rerangedCount - count;␊
266#endif␊
267␊
268␉// Copy out data␊
269␉bcopy((char *)BIOS_ADDR, rangeArray, ((char *)range - (char *)BIOS_ADDR));␊
270␊
271#if DEBUG␊
272␉{␊
273␉int i;␊
274 printf("%d total ranges\n", count);␊
275␊
276␉␉getchar();␊
277␊
278␉␉for (i = 0, range = rangeArray; i<count; i++, range++)␊
279␉␉{␊
280␉␉␉printf("range: type %d, base 0x%x, length 0x%x\n",␊
281␉␉␉range->type, (unsigned int)range->base, (unsigned int)range->length);␊
282␉␉␉getchar();␊
283␉␉}␊
284␉}␊
285#endif␊
286␊
287␉return count;␊
288}␊
289␊
290␊
291//==============================================================================␊
292␊
293␊
294unsigned long getExtendedMemorySize()␊
295{␊
296␉// Get extended memory size for large configurations. Not used unless␊
297␉// the INT15, E820H call (Get System Address Map) failed.␊
298␉//␊
299␉// Input:␊
300␉//␊
301␉// AX Function Code E801h␊
302␉//␊
303␉// Outputs:␊
304␉//␊
305␉// CF Carry Flag Carry cleared indicates no error.␊
306␉// AX Extended 1 Number of contiguous KB between 1 and 16 MB,␊
307␉// maximum 0x3C00 = 15 MB.␊
308␉// BX Extended 2 Number of contiguous 64 KB blocks between␊
309␉// 16 MB and 4 GB.␊
310␉// CX Configured 1 Number of contiguous KB between 1 and 16 MB,␊
311␉// maximum 0x3C00 = 15 MB.␊
312␉// DX Configured 2 Number of contiguous 64 KB blocks between␊
313␉// 16 MB and 4 GB.␊
314␊
315␉bb.intno = 0x15;␊
316␉bb.eax.rx = 0xe801;␊
317␉bios(&bb);␊
318␊
319␉// Return the size of memory above 1MB (extended memory) in kilobytes.␊
320␊
321␉if (bb.flags.cf == 0)␊
322␉{␊
323␉␉return (bb.ebx.rr * 64 + bb.eax.rr);␊
324␉}␊
325␊
326␉// Get Extended memory size. Called on last resort since the return␊
327␉// value is limited to 16-bits (a little less than 64MB max). May␊
328␉// not be supported by modern BIOSes.␊
329␉//␊
330␉// Input:␊
331␉//␊
332␉// AX Function Code E801h␊
333␉//␊
334␉// Outputs:␊
335␉//␊
336␉// CF Carry Flag Carry cleared indicates no error.␊
337␉// AX Memory Count Number of contiguous KB above 1MB.␊
338␊
339␉bb.intno = 0x15;␊
340␉bb.eax.rx = 0x88;␊
341␉bios(&bb);␊
342␊
343␉// Return the size of memory above 1MB (extended memory) in kilobytes.␊
344␊
345␉return bb.flags.cf ? 0 : bb.eax.rr;␊
346}␊
347␊
348␊
349//==============================================================================␊
350␊
351␊
352unsigned long getConventionalMemorySize()␊
353{␊
354␉bb.intno = 0x12;␊
355␉bios(&bb);␊
356␊
357␉return bb.eax.rr; // kilobytes␊
358}␊
359␊
360␊
361//==============================================================================␊
362␊
363␊
364void video_mode(int mode)␊
365{␊
366␉bb.intno = 0x10;␊
367␉bb.eax.r.h = 0x00;␊
368␉bb.eax.r.l = mode;␊
369␉bios(&bb);␊
370}␊
371␊
372␊
373//==============================================================================␊
374␊
375int biosread(int dev, int cyl, int head, int sec, int num)␊
376{␊
377␉int i;␊
378␊
379␉bb.intno = 0x13;␊
380␉sec += 1; // sector numbers start at 1.␊
381 ␊
382␉for (i=0;;)␊
383␉{␊
384␉␉bb.ecx.r.h = cyl;␊
385␉␉bb.ecx.r.l = ((cyl & 0x300) >> 2) | (sec & 0x3F);␊
386␉␉bb.edx.r.h = head;␊
387␉␉bb.edx.r.l = dev;␊
388␉␉bb.eax.r.l = num;␊
389␉␉bb.ebx.rr = OFFSET(ptov(BIOS_ADDR));␊
390␉␉bb.es = SEGMENT(ptov(BIOS_ADDR));␊
391␊
392␉␉bb.eax.r.h = 0x02;␊
393␉␉bios(&bb);␊
394␊
395␉␉// In case of a successful call, make sure we set AH (return code) to zero.␊
396␉␉if (bb.flags.cf == 0)␊
397␉␉{␊
398␉␉␉bb.eax.r.h = 0;␊
399␉␉}␊
400␊
401␉␉// Now we can really check for the return code (AH) value.␊
402␉␉if ((bb.eax.r.h == 0x00) || (i++ >= 5))␊
403␉␉{␊
404␉␉␉break;␊
405␉␉}␊
406␊
407 // Reset disk subsystem and try again.␊
408␉␉bb.eax.r.h = 0x00;␊
409␉␉bios(&bb);␊
410␉}␊
411␊
412␉return bb.eax.r.h;␊
413}␊
414␊
415␊
416//==============================================================================␊
417␊
418int ebiosread(int dev, unsigned long long sec, int count)␊
419{␊
420␉int i;␊
421␊
422␉static struct␊
423␉{␊
424␉␉unsigned char size;␊
425␉␉unsigned char reserved;␊
426␉␉unsigned char numblocks;␊
427␉␉unsigned char reserved2;␊
428␉␉unsigned short bufferOffset;␊
429␉␉unsigned short bufferSegment;␊
430␉␉unsigned long long startblock;␊
431␉} addrpacket __attribute__((aligned(16))) = {0};␊
432␉addrpacket.size = sizeof(addrpacket);␊
433␊
434␉for (i = 0; ;)␊
435␉{␊
436␉␉bb.intno = 0x13;␊
437␉␉bb.eax.r.h = 0x42;␊
438␉␉bb.edx.r.l = dev;␊
439␉␉bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket);␊
440␉␉bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket);␊
441␉␉addrpacket.reserved = addrpacket.reserved2 = 0;␊
442␉␉addrpacket.numblocks = count;␊
443␉␉addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR));␊
444␉␉addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR));␊
445␉␉addrpacket.startblock = sec;␊
446␉␉bios(&bb);␊
447␊
448␉␉// In case of a successful call, make sure we set AH (return code) to zero.␊
449␉␉if (bb.flags.cf == 0)␊
450␉␉{␊
451␉␉␉bb.eax.r.h = 0;␊
452␉␉}␊
453␊
454␉␉// Now we can really check for the return code (AH) value.␊
455␉␉if ((bb.eax.r.h == 0x00) || (i++ >= 5))␊
456␉␉{␊
457␉␉␉break;␊
458␉␉}␊
459␊
460 // Reset disk subsystem and try again.␊
461␉␉bb.eax.r.h = 0x00;␊
462␉␉bios(&bb);␊
463␉}␊
464␊
465␉return bb.eax.r.h;␊
466}␊
467␊
468//==============================================================================␊
469␊
470int ebioswrite(int dev, long sec, int count)␊
471{␊
472␉int i;␊
473␉static struct␊
474␉{␊
475␉␉unsigned char size;␊
476␉␉unsigned char reserved;␊
477␉␉unsigned char numblocks;␊
478␉␉unsigned char reserved2;␊
479␉␉unsigned short bufferOffset;␊
480␉␉unsigned short bufferSegment;␊
481␉␉unsigned long long startblock;␊
482␉} addrpacket __attribute__((aligned(16))) = {0};␊
483␉addrpacket.size = sizeof(addrpacket);␊
484␊
485␉for (i=0;;)␊
486␉{␊
487␉␉bb.intno = 0x13;␊
488␉␉bb.eax.r.l = 0; /* Don't verify */␊
489␉␉bb.eax.r.h = 0x43;␊
490␉␉bb.edx.r.l = dev;␊
491␉␉bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket);␊
492␉␉bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket);␊
493␉␉addrpacket.reserved = addrpacket.reserved2 = 0;␊
494␉␉addrpacket.numblocks = count;␊
495␉␉addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR));␊
496␉␉addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR));␊
497␉␉addrpacket.startblock = sec;␊
498␉␉bios(&bb);␊
499␊
500␉␉/* In case of a successful call, make sure we set AH (return code) to zero. */␊
501␉␉if (bb.flags.cf == 0)␊
502␉␉␉bb.eax.r.h = 0;␊
503␊
504␉␉/* Now we can really check for the return code (AH) value. */␊
505␉␉if ((bb.eax.r.h == 0x00) || (i++ >= 5))␊
506␉␉break;␊
507␊
508␉␉/* reset disk subsystem and try again */␊
509␉␉bb.eax.r.h = 0x00;␊
510␉␉bios(&bb);␊
511␉}␊
512␉return bb.eax.r.h;␊
513}␊
514␊
515void bios_putchar(int ch)␊
516{␊
517␉bb.intno = 0x10;␊
518␉bb.ebx.r.h = 0x00; /* background black */␊
519␉bb.ebx.r.l = 0x0F; /* foreground white */␊
520␉bb.eax.r.h = 0x0e;␊
521␉bb.eax.r.l = ch;␊
522␉bios(&bb);␊
523}␊
524␊
525␊
526//==============================================================================␊
527␊
528void putca(int ch, int attr, int repeat)␊
529{␊
530␉bb.intno = 0x10;␊
531␉bb.ebx.r.h = 0x00; /* page number */␊
532␉bb.ebx.r.l = attr; /* attribute */␊
533␉bb.eax.r.h = 0x9;␊
534␉bb.eax.r.l = ch;␊
535␉bb.ecx.rx = repeat; /* repeat count */ ␊
536␉bios(&bb);␊
537}␊
538␊
539␊
540//==============================================================================␊
541// Check to see if the passed-in drive is in El Torito no-emulation mode.␊
542␊
543int is_no_emulation(int drive)␊
544{␊
545␉struct packet␊
546␉{␊
547␉␉unsigned char packet_size;␊
548␉␉unsigned char media_type;␊
549␉␉unsigned char drive_num;␊
550␉␉unsigned char ctrlr_index;␊
551␉␉unsigned long lba;␊
552␉␉unsigned short device_spec;␊
553␉␉unsigned short buffer_segment;␊
554␉␉unsigned short load_segment;␊
555␉␉unsigned short sector_count;␊
556␉␉unsigned char cyl_count;␊
557␉␉unsigned char sec_count;␊
558␉␉unsigned char head_count;␊
559␉␉unsigned char reseved;␊
560␉} __attribute__((packed));␊
561␉static struct packet pkt;␊
562␊
563␉bzero(&pkt, sizeof(pkt));␊
564␉pkt.packet_size = 0x13;␊
565␊
566␉bb.intno = 0x13;␊
567␉bb.eax.r.h = 0x4b;␊
568␉bb.eax.r.l = 0x01; // subfunc: get info␊
569␉bb.edx.r.l = drive;␊
570␉bb.esi.rr = NORMALIZED_OFFSET((unsigned)&pkt);␊
571␉bb.ds = NORMALIZED_SEGMENT((unsigned)&pkt);␊
572␊
573␉bios(&bb);␊
574␊
575#if DEBUG␊
576␉printf("el_torito info drive %x\n", drive);␊
577␉printf("--> cf %x, eax %x\n", bb.flags.cf, bb.eax.rr);␊
578␉printf("pkt_size: %x\n", pkt.packet_size);␊
579␉printf("media_type: %x\n", pkt.media_type);␊
580␉printf("drive_num: %x\n", pkt.drive_num);␊
581␉printf("device_spec: %x\n", pkt.device_spec);␊
582␊
583␉pause();␊
584#endif␊
585␊
586␉/* Some BIOSes erroneously return cf = 1 */␊
587␉/* Just check to see if the drive number is the same. */␊
588␉if (pkt.drive_num == drive)␊
589␉{␊
590␉␉if ((pkt.media_type & 0x0F) == 0)␊
591␉␉{␊
592␉␉␉/* We are in no-emulation mode. */␊
593␉␉␉return 1;␊
594␉␉}␊
595␉}␊
596␉return 0;␊
597}␊
598␊
599#if DEBUG␊
600/*␊
601 * BIOS drive information.␊
602 */␊
603void print_drive_info(boot_drive_info_t *dp)␊
604{␊
605//␉printf("buf_size = %x\n", dp->params.buf_size);␊
606␉printf("info_flags = %x\n", dp->params.info_flags);␊
607␉printf("phys_cyls = %lx\n", dp->params. phys_cyls);␊
608␉printf("phys_heads = %lx\n", dp->params. phys_heads);␊
609␉printf("phys_spt = %lx\n", dp->params. phys_spt);␊
610␉printf("phys_sectors = %lx%lx\n", ((unsigned long *)(&dp->params.phys_sectors))[1],␊
611␉␉ ((unsigned long *)(&dp->params.phys_sectors))[0]);␊
612␉printf("phys_nbps = %x\n", dp->params.phys_nbps);␊
613//␉printf("dpte_offset = %x\n", dp->params.dpte_offset);␊
614//␉printf("dpte_segment = %x\n", dp->params.dpte_segment);␊
615//␉printf("key = %x\n", dp->params.key);␊
616//␉printf("path_len = %x\n", dp->params. path_len);␊
617//␉printf("reserved1 = %x\n", dp->params. reserved1);␊
618//␉printf("reserved2 = %x\n", dp->params.reserved2);␊
619//␉printf("bus_type[4] = %x\n", dp->params. bus_type[4]);␊
620//␉printf("interface_type[8] = %x\n", dp->params. interface_type[8]);␊
621//␉printf("interface_path[8] = %x\n", dp->params. interface_path[8]);␊
622//␉printf("dev_path[8] = %x\n", dp->params. dev_path[8]);␊
623//␉printf("reserved3 = %x\n", dp->params. reserved3);␊
624//␉printf("checksum = %x\n", dp->params. checksum);␊
625␉printf("io_port_base = %x\n", dp->dpte.io_port_base);␊
626␉printf("control_port_base = %x\n", dp->dpte.control_port_base);␊
627␉printf("head_flags = %x\n", dp->dpte. head_flags);␊
628␉printf("vendor_info = %x\n", dp->dpte. vendor_info);␊
629␉printf("irq = %x\n", dp->dpte. irq);␊
630//␉printf("irq_unused = %x\n", dp->dpte. irq_unused);␊
631␉printf("block_count = %x\n", dp->dpte. block_count);␊
632␉printf("dma_channe = %x\n", dp->dpte. dma_channel);␊
633␉printf("dma_type = %x\n", dp->dpte. dma_type);␊
634␉printf("pio_type = %x\n", dp->dpte. pio_type);␊
635␉printf("pio_unused = %x\n", dp->dpte. pio_unused);␊
636␉printf("option_flags = %x\n", dp->dpte.option_flags);␊
637//␉printf("reserved = %x\n", dp->dpte.reserved);␊
638␉printf("revision = %x\n", dp->dpte. revision);␊
639//␉printf("checksum = %x\n", dp->dpte. checksum);␊
640}␊
641␊
642#endif␊
643␊
644//==============================================================================␊
645␊
646int get_drive_info(int drive, struct driveInfo *dp)␊
647{␊
648␉boot_drive_info_t *di = &dp->di;␊
649␉int ret = 0;␊
650␊
651#if UNUSED␊
652␉if (maxhd == 0)␊
653␉{␊
654␉␉bb.intno = 0x13;␊
655␉␉bb.eax.r.h = 0x08;␊
656␉␉bb.edx.r.l = 0x80;␊
657␉␉bios(&bb);␊
658␊
659␉␉if (bb.flags.cf == 0)␊
660␉␉␉maxhd = 0x7f + bb.edx.r.l;␊
661␉};␊
662␊
663␉if (drive > maxhd)␊
664␉␉return 0;␊
665#endif␊
666␊
667␉bzero(dp, sizeof(struct driveInfo));␊
668␉dp->biosdev = drive;␊
669␊
670␉/* Check for El Torito no-emulation mode. */␊
671␉dp->no_emulation = is_no_emulation(drive);␊
672␊
673␉/* Check drive for EBIOS support. */␊
674␉bb.intno = 0x13;␊
675␉bb.eax.r.h = 0x41;␊
676␉bb.edx.r.l = drive;␊
677␉bb.ebx.rr = 0x55aa;␊
678␉bios(&bb);␊
679␉␊
680␉if ((bb.ebx.rr == 0xaa55) && (bb.flags.cf == 0))␊
681␉{␊
682␉␉/* Get flags for supported operations. */␊
683␉␉dp->uses_ebios = bb.ecx.r.l;␊
684␉}␊
685␉␊
686␉if (dp->uses_ebios & (EBIOS_ENHANCED_DRIVE_INFO | EBIOS_LOCKING_ACCESS | EBIOS_FIXED_DISK_ACCESS))␊
687␉{␊
688␉␉/* Get EBIOS drive info. */␊
689␉␉static struct drive_params params;␊
690␉␉␊
691␉␉params.buf_size = sizeof(params);␊
692␉␉bb.intno = 0x13;␊
693␉␉bb.eax.r.h = 0x48;␊
694␉␉bb.edx.r.l = drive;␊
695␉␉bb.esi.rr = NORMALIZED_OFFSET((unsigned)&params);␊
696␉␉bb.ds␉ = NORMALIZED_SEGMENT((unsigned)&params);␊
697␉␉bios(&bb);␊
698␉␉␊
699␉␉if (bb.flags.cf != 0 /* || params.phys_sectors < 2097152 */)␊
700␉␉{␊
701␉␉␉dp->uses_ebios = 0;␊
702␉␉␉di->params.buf_size = 1;␊
703␉␉}␊
704␉␉else␊
705␉␉{␊
706␉␉␉bcopy(&params, &di->params, sizeof(params));␊
707␉␉␉␊
708␉␉␉if (drive >= BASE_HD_DRIVE &&␊
709␉␉␉␉(dp->uses_ebios & EBIOS_ENHANCED_DRIVE_INFO) &&␊
710␉␉␉␉di->params.buf_size >= 30 &&␊
711␉␉␉␉!(di->params.dpte_offset == 0xFFFF && di->params.dpte_segment == 0xFFFF))␊
712␉␉␉{␊
713␉␉␉␉␉void *ptr = (void *)(di->params.dpte_offset + ((unsigned int)di->params.dpte_segment << 4));␊
714␉␉␉␉␉bcopy(ptr, &di->dpte, sizeof(di->dpte));␊
715␉␉␉}␊
716␉␉}␊
717␉}␊
718␊
719/*␊
720 * zef: This code will fail on recent JMicron and Intel option ROMs␊
721 */ ␊
722//␉if (di->params.phys_heads == 0 || di->params.phys_spt == 0) {␊
723//␉␉/* Either it's not EBIOS, or EBIOS didn't tell us. */␊
724//␉␉bb.intno = 0x13;␊
725//␉␉bb.eax.r.h = 0x08;␊
726//␉␉bb.edx.r.l = drive;␊
727//␉␉bios(&bb);␊
728//␉␉if (bb.flags.cf == 0 && bb.eax.r.h == 0) {␊
729//␉␉␉unsigned long cyl;␊
730//␉␉␉unsigned long sec;␊
731//␉␉␉unsigned long hds;␊
732//␉␉␊
733//␉␉␉hds = bb.edx.r.h;␊
734//␉␉␉sec = bb.ecx.r.l & 0x3F;␊
735//␉␉␉if ((dp->uses_ebios & EBIOS_ENHANCED_DRIVE_INFO) && (sec != 0)) {␊
736//␉␉␉␉cyl = (di->params.phys_sectors / ((hds + 1) * sec)) - 1;␊
737//␉␉␉} else {␊
738//␉␉␉␉cyl = bb.ecx.r.h | ((bb.ecx.r.l & 0xC0) << 2);␊
739//␉␉␉}␊
740//␉␉␉di->params.phys_heads = hds; ␊
741//␉␉␉di->params.phys_spt = sec;␊
742//␉␉␉di->params.phys_cyls = cyl;␊
743//␉␉} else {␊
744//␉␉␉ret = -1;␊
745//␉␉}␊
746//␉}␊
747␊
748␉if (dp->no_emulation)␊
749␉{␊
750␉␉/* Some BIOSes give us erroneous EBIOS support information.␊
751␉ ␉ * Assume that if you're on a CD, then you can use␊
752␉ ␉ * EBIOS disk calls.␊
753␉ ␉ */␊
754␉␉dp->uses_ebios |= EBIOS_FIXED_DISK_ACCESS;␊
755␉}␊
756#if DEBUG␊
757␉print_drive_info(di);␊
758␉printf("uses_ebios = 0x%x\n", dp->uses_ebios);␊
759␉printf("result %d\n", ret);␊
760␉pause();␊
761#endif␊
762␊
763␉if (ret == 0)␊
764␉{␊
765␉␉dp->valid = 1;␊
766␉}␊
767␉return ret;␊
768}␊
769␊
770//==============================================================================␊
771␊
772int ebiosEjectMedia(int biosdev)␊
773{␊
774␉bb.intno = 0x13;␊
775␉bb.eax.r.h = 0x46;␊
776␉bb.eax.r.l = 0;␊
777␉bb.edx.rx = biosdev;␊
778␉bios(&bb);␊
779␉return bb.eax.r.h;␊
780}␊
781␊
782void setCursorPosition(int x, int y, int page)␊
783{␊
784␉bb.intno = 0x10;␊
785␉bb.eax.r.h = 0x02;␊
786␉bb.ebx.r.h = page; /* page 0 for graphics */␊
787␉bb.edx.r.l = x;␊
788␉bb.edx.r.h = y;␊
789␉bios(&bb);␊
790}␊
791␊
792void setCursorType(int type)␊
793{␊
794␉bb.intno = 0x10;␊
795␉bb.eax.r.h = 0x01;␊
796␉bb.ecx.rr = type;␊
797␉bios(&bb);␊
798}␊
799␊
800void getCursorPositionAndType(int * x, int * y, int * type)␊
801{␊
802␉bb.intno = 0x10;␊
803␉bb.eax.r.h = 0x03;␊
804␉bios(&bb);␊
805␉*x = bb.edx.r.l;␊
806␉*y = bb.edx.r.h;␊
807␉*type = bb.ecx.rr;␊
808}␊
809␊
810void scollPage(int x1, int y1, int x2, int y2, int attr, int rows, int dir)␊
811{␊
812␉bb.intno = 0x10;␊
813␉bb.eax.r.h = (dir > 0) ? 0x06 : 0x07;␊
814␉bb.eax.r.l = rows;␊
815␉bb.ebx.r.h = attr;␊
816␉bb.ecx.r.h = y1;␊
817␉bb.ecx.r.l = x1;␊
818␉bb.edx.r.h = y2;␊
819␉bb.edx.r.l = x2;␊
820␉bios(&bb);␊
821}␊
822␊
823void clearScreenRows( int y1, int y2 )␊
824{␊
825␉scollPage( 0, y1, 80 - 1, y2, 0x07, y2 - y1 + 1, 1 );␊
826}␊
827␊
828void setActiveDisplayPage( int page )␊
829{␊
830␉bb.intno = 0x10;␊
831␉bb.eax.r.h = 5;␊
832␉bb.eax.r.l = page;␊
833␉bios(&bb);␊
834}␊
835␊
836#if DEBUG␊
837␊
838int terminateDiskEmulation()␊
839{␊
840␉static char cd_spec[0x13];␊
841␊
842␉bb.intno = 0x13;␊
843␉bb.eax.r.h = 0x4b;␊
844␉bb.eax.r.l = 0; // subfunc: terminate emulation ␊
845␉bb.esi.rr = NORMALIZED_OFFSET((unsigned)&cd_spec);␊
846␉bb.ds = NORMALIZED_SEGMENT((unsigned)&cd_spec);␊
847␉bios(&bb);␊
848␉return bb.eax.r.h;␊
849}␊
850␊
851int readDriveParameters(int drive, struct driveParameters *dp)␊
852{␊
853␉bb.intno = 0x13;␊
854␉bb.edx.r.l = drive;␊
855␉bb.eax.r.h = 0x08;␊
856␉bios(&bb);␊
857␉if (bb.eax.r.h == 0)␊
858␉{␊
859␉␉dp->heads = bb.edx.r.h;␊
860␉␉dp->sectors = bb.ecx.r.l & 0x3F;␊
861␉␉dp->cylinders = bb.ecx.r.h | ((bb.ecx.r.l & 0xC0) << 2);␊
862␉␉dp->totalDrives = bb.edx.r.l;␊
863␉}␊
864␉else␊
865␉{␊
866␉␉bzero(dp, sizeof(*dp));␊
867␉}␊
868␉return bb.eax.r.h;␊
869}␊
870#endif␊
871␊
872#ifdef APM_SUPPORT␊
873␊
874#define APM_INTNO 0x15␊
875#define APM_INTCODE 0x53␊
876␊
877int APMPresent(void)␊
878{␊
879␉bb.intno = APM_INTNO;␊
880␉bb.eax.r.h = APM_INTCODE;␊
881␉bb.eax.r.l = 0x00;␊
882␉bb.ebx.rr = 0x0000;␊
883␉bios(&bb);␊
884␉if ((bb.flags.cf == 0) && (bb.ebx.r.h == 'P') && (bb.ebx.r.l == 'M'))␊
885␉{␊
886␉␉/* Success */␊
887␉␉bootArgs->apmConfig.major_vers = bb.eax.r.h;␊
888␉␉bootArgs->apmConfig.minor_vers = bb.eax.r.l;␊
889␉␉bootArgs->apmConfig.flags.data = bb.ecx.rr;␊
890␉␉return 1;␊
891␉}␊
892␉return 0;␊
893}␊
894␊
895int APMConnect32(void)␊
896{␊
897␉bb.intno = APM_INTNO;␊
898␉bb.eax.r.h = APM_INTCODE;␊
899␉bb.eax.r.l = 0x03;␊
900␉bb.ebx.rr = 0x0000;␊
901␉bios(&bb);␊
902␉if (bb.flags.cf == 0)␊
903␉{␊
904␉␉/* Success */␊
905␉␉bootArgs->apmConfig.cs32_base = (bb.eax.rr) << 4;␊
906␉␉bootArgs->apmConfig.entry_offset = bb.ebx.rx;␊
907␉␉bootArgs->apmConfig.cs16_base = (bb.ecx.rr) << 4;␊
908␉␉bootArgs->apmConfig.ds_base = (bb.edx.rr) << 4;␊
909␉␉if (bootArgs->apmConfig.major_vers >= 1 && bootArgs->apmConfig.minor_vers >= 1)␊
910␉␉{␊
911␉␉␉bootArgs->apmConfig.cs_length = bb.esi.rr;␊
912␉␉␉bootArgs->apmConfig.ds_length = bb.edi.rr;␊
913␉␉}␊
914␉␉else␊
915␉␉{␊
916␉␉␉bootArgs->apmConfig.cs_length = ␊
917␉␉␉bootArgs->apmConfig.ds_length = 64 * 1024;␊
918␉␉}␊
919␉␉bootArgs->apmConfig.connected = 1;␊
920␉␉return 1;␊
921␉}␊
922␉return 0;␊
923}␊
924␊
925#endif /* APM_SUPPORT */␊
926␊
927#ifdef EISA_SUPPORT␊
928bool eisa_present(void)␊
929{␊
930␉static bool checked = false;␊
931␉static bool isEISA;␊
932␊
933␉if (!checked)␊
934␉{␊
935␉␉if (strncmp((char *)0xfffd9, "EISA", 4) == 0)␊
936␉␉␉isEISA = true;␊
937␊
938␉␉checked = true;␊
939␉}␊
940␊
941␉return (isEISA);␊
942}␊
943␊
944int␊
945ReadEISASlotInfo(EISA_slot_info_t *ep, int slot)␊
946{␊
947␉union␊
948␉{␊
949␉␉struct␊
950␉␉{␊
951␉␉␉unsigned char char2h :2;␊
952␉␉␉unsigned char char1 :5;␊
953␉␉␉unsigned char char3 :5;␊
954␉␉␉unsigned char char2l :3;␊
955␉␉␉unsigned char d2 :4;␊
956␉␉␉unsigned char d1 :4;␊
957␉␉␉unsigned char d4 :4;␊
958␉␉␉unsigned char d3 :4;␊
959␉␉} s;␊
960␉␉unsigned char data[4];␊
961␉} u;␊
962␉static char hex[0x10] = "0123456789ABCDEF";␊
963␊
964␊
965␉bb.intno = 0x15;␊
966␉bb.eax.r.h = 0xd8;␊
967␉bb.eax.r.l = 0x00;␊
968␉bb.ecx.r.l = slot;␊
969␉bios(&bb);␊
970␉if (bb.flags.cf)␊
971␉␉return bb.eax.r.h;␊
972␉ep->u_ID.d = bb.eax.r.l;␊
973␉ep->configMajor = bb.ebx.r.h;␊
974␉ep->configMinor = bb.ebx.r.l;␊
975␉ep->checksum = bb.ecx.rr;␊
976␉ep->numFunctions = bb.edx.r.h;␊
977␉ep->u_resources.d = bb.edx.r.l;␊
978␉u.data[0] = bb.edi.r.l;␊
979␉u.data[1] = bb.edi.r.h;␊
980␉u.data[2] = bb.esi.r.l;␊
981␉u.data[3] = bb.esi.r.h;␊
982␉ep->id[0] = u.s.char1 + ('A' - 1);␊
983␉ep->id[1] = (u.s.char2l | (u.s.char2h << 3)) + ('A' - 1);␊
984␉ep->id[2] = u.s.char3 + ('A' - 1);␊
985␉ep->id[3] = hex[u.s.d1];␊
986␉ep->id[4] = hex[u.s.d2];␊
987␉ep->id[5] = hex[u.s.d3];␊
988␉ep->id[6] = hex[u.s.d4];␊
989␉ep->id[7] = 0;␊
990␉return 0;␊
991}␊
992␊
993/*␊
994 * Note: ep must point to an address below 64k.␊
995 */␊
996␊
997int␊
998ReadEISAFuncInfo(EISA_func_info_t *ep, int slot, int function)␊
999{␊
1000␉bb.intno = 0x15;␊
1001␉bb.eax.r.h = 0xd8;␊
1002␉bb.eax.r.l = 0x01;␊
1003␉bb.ecx.r.l = slot;␊
1004␉bb.ecx.r.h = function;␊
1005␉bb.esi.rr = (unsigned int)ep->data;␊
1006␉bios(&bb);␊
1007␉if (bb.eax.r.h == 0)␊
1008␉{␊
1009␉␉ep->slot = slot;␊
1010␉␉ep->function = function;␊
1011␉}␊
1012␉return bb.eax.r.h;␊
1013}␊
1014#endif /* EISA_SUPPORT */␊
1015␊
1016#define PCI_SIGNATURE 0x20494350 /* "PCI " */␊
1017␊
1018int␊
1019ReadPCIBusInfo(PCI_bus_info_t *pp)␊
1020{␊
1021␉bb.intno = 0x1a;␊
1022␉bb.eax.r.h = 0xb1;␊
1023␉bb.eax.r.l = 0x01;␊
1024␉bios(&bb);␊
1025␉if ((bb.eax.r.h == 0) && (bb.edx.rx == PCI_SIGNATURE))␊
1026␉{␊
1027␉␉pp->BIOSPresent = 1;␊
1028␉␉pp->u_bus.d = bb.eax.r.l;␊
1029␉␉pp->majorVersion = bb.ebx.r.h;␊
1030␉␉pp->minorVersion = bb.ebx.r.l;␊
1031␉␉pp->maxBusNum = bb.ecx.r.l;␊
1032␉␉return 0;␊
1033␉}␊
1034␉return -1;␊
1035}␊
1036␊
1037void sleep(int n)␊
1038{␊
1039 unsigned int endtime = (time18() + 18*n);␊
1040 while (time18() < endtime);␊
1041}␊
1042␊
1043␊
1044//==============================================================================␊
1045␊
1046void delay(int ms)␊
1047{␊
1048 bb.intno = 0x15;␊
1049 bb.eax.r.h = 0x86;␊
1050 bb.ecx.rr = ms >> 16;␊
1051 bb.edx.rr = ms & 0xFFFF;␊
1052 bios(&bb);␊
1053}␊
1054␊
1055

Archive Download this file

Revision: 2037