Chameleon

Chameleon Svn Source Tree

Root/branches/rewrite/i386/libsaio/biosfn.c

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

Archive Download this file

Revision: 1066