Chameleon

Chameleon Svn Source Tree

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

Source at commit 1079 created 9 years 14 days ago.
By meklort, began implimenting Bios disk changes. Code taken from 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 "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{
106int i, still_changing, newcount = count;
107
108MemoryRange * range = (MemoryRange *)BIOS_ADDR;
109struct MemoryRange change_tmp;
110
111/* sort map list by memory addresses (low -> high) */
112still_changing = 1;
113while (still_changing) {
114still_changing = 0;
115for (i=1; i<count; i++) {
116/* if <current_addr> > <last_addr>, swap */
117if (range[i].base < range[i-1].base) {
118change_tmp.base = range[i].base;
119change_tmp.length = range[i].length;
120change_tmp.type = range[i].type;
121
122range[i].base = range[i-1].base;
123range[i].length = range[i-1].length;
124range[i].type = range[i-1].type;
125
126range[i-1].base = change_tmp.base;
127range[i-1].length = change_tmp.length;
128range[i-1].type = change_tmp.type;
129
130still_changing=1;
131}
132}
133}
134
135/* clear overlaps */
136/* linux's arch/i386/kern/setup.c may have better algorithm */
137for (i=1; i<count; i++) {
138if ( range[i-1].base + range[i-1].length > range[i].base ) {
139range[newcount].base = range[i].base + range[i].length;
140range[newcount].length = range[i-1].base + range[i-1].length - range[newcount].base;
141range[newcount].type = range[i-1].type;
142newcount++;
143
144range[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 */
153range[newcount].base = 0xb0000000;
154range[newcount].length = 0x0f000000;
155range[newcount].type = kMemoryRangeUsable;
156newcount++;
157
158return 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 longcount = 0;
172 // unsigned longrerangedCount;
173 unsigned long longconMemSize = 0;
174 unsigned long longextMemSize = 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{
474struct packet {
475unsigned char packet_size;
476unsigned char media_type;
477unsigned char drive_num;
478unsigned char ctrlr_index;
479unsigned long lba;
480unsigned short device_spec;
481unsigned short buffer_segment;
482unsigned short load_segment;
483unsigned short sector_count;
484unsigned char cyl_count;
485unsigned char sec_count;
486unsigned char head_count;
487unsigned char reseved;
488} __attribute__((packed));
489static struct packet pkt;
490
491bzero(&pkt, sizeof(pkt));
492pkt.packet_size = 0x13;
493
494bb.intno= 0x13;
495bb.eax.r.h= 0x4b;
496bb.eax.r.l= 0x01; // subfunc: get info
497bb.edx.r.l= drive;
498bb.esi.rr= NORMALIZED_OFFSET((unsigned)&pkt);
499bb.ds= NORMALIZED_SEGMENT((unsigned)&pkt);
500
501bios(&bb);
502#if DEBUG
503printf("el_torito info drive %x\n", drive);
504
505printf("--> cf %x, eax %x\n", bb.flags.cf, bb.eax.rr);
506
507printf("pkt_size: %x\n", pkt.packet_size);
508printf("media_type: %x\n", pkt.media_type);
509printf("drive_num: %x\n", pkt.drive_num);
510printf("device_spec: %x\n", pkt.device_spec);
511pause();
512#endif
513
514/* Some BIOSes erroneously return cf = 1 */
515/* Just check to see if the drive number is the same. */
516if (pkt.drive_num == drive) {
517if ((pkt.media_type & 0x0F) == 0) {
518/* We are in no-emulation mode. */
519return 1;
520}
521}
522return 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);
532printf("info_flags = %x\n", dp->params.info_flags);
533printf("phys_cyls = %lx\n", dp->params. phys_cyls);
534printf("phys_heads = %lx\n", dp->params. phys_heads);
535printf("phys_spt = %lx\n", dp->params. phys_spt);
536printf("phys_sectors = %lx%lx\n", ((unsigned long *)(&dp->params.phys_sectors))[1],
537 ((unsigned long *)(&dp->params.phys_sectors))[0]);
538printf("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);
551printf("io_port_base = %x\n", dp->dpte.io_port_base);
552printf("control_port_base = %x\n", dp->dpte.control_port_base);
553printf("head_flags = %x\n", dp->dpte. head_flags);
554printf("vendor_info = %x\n", dp->dpte. vendor_info);
555printf("irq = %x\n", dp->dpte. irq);
556//printf("irq_unused = %x\n", dp->dpte. irq_unused);
557printf("block_count = %x\n", dp->dpte. block_count);
558printf("dma_channe = %x\n", dp->dpte. dma_channel);
559printf("dma_type = %x\n", dp->dpte. dma_type);
560printf("pio_type = %x\n", dp->dpte. pio_type);
561printf("pio_unused = %x\n", dp->dpte. pio_unused);
562printf("option_flags = %x\n", dp->dpte.option_flags);
563//printf("reserved = %x\n", dp->dpte.reserved);
564printf("revision = %x\n", dp->dpte. revision);
565//printf("checksum = %x\n", dp->dpte. checksum);
566}
567
568#endif
569
570int ebiosEjectMedia(int biosdev)
571{
572 bb.intno = 0x13;
573 bb.eax.r.h = 0x46;
574 bb.eax.r.l = 0;
575 bb.edx.rx = biosdev;
576 bios(&bb);
577 return bb.eax.r.h;
578}
579
580void setCursorPosition(int x, int y, int page)
581{
582 bb.intno = 0x10;
583 bb.eax.r.h = 0x02;
584 bb.ebx.r.h = page; /* page 0 for graphics */
585 bb.edx.r.l = x;
586 bb.edx.r.h = y;
587 bios(&bb);
588}
589
590void setCursorType(int type)
591{
592 bb.intno = 0x10;
593 bb.eax.r.h = 0x01;
594 bb.ecx.rr = type;
595 bios(&bb);
596}
597
598void getCursorPositionAndType(int * x, int * y, int * type)
599{
600 bb.intno = 0x10;
601 bb.eax.r.h = 0x03;
602 bios(&bb);
603 *x = bb.edx.r.l;
604 *y = bb.edx.r.h;
605 *type = bb.ecx.rr;
606}
607
608void scollPage(int x1, int y1, int x2, int y2, int attr, int rows, int dir)
609{
610 bb.intno = 0x10;
611 bb.eax.r.h = (dir > 0) ? 0x06 : 0x07;
612 bb.eax.r.l = rows;
613 bb.ebx.r.h = attr;
614 bb.ecx.r.h = y1;
615 bb.ecx.r.l = x1;
616 bb.edx.r.h = y2;
617 bb.edx.r.l = x2;
618 bios(&bb);
619}
620
621void clearScreenRows( int y1, int y2 )
622{
623 scollPage( 0, y1, 80 - 1, y2, 0x07, y2 - y1 + 1, 1 );
624}
625
626void setActiveDisplayPage( int page )
627{
628 bb.intno = 0x10;
629 bb.eax.r.h = 5;
630 bb.eax.r.l = page;
631 bios(&bb);
632}
633
634#if DEBUG
635
636int terminateDiskEmulation()
637{
638 static char cd_spec[0x13];
639
640 bb.intno = 0x13;
641 bb.eax.r.h = 0x4b;
642 bb.eax.r.l = 0; // subfunc: terminate emulation
643 bb.esi.rr = NORMALIZED_OFFSET((unsigned)&cd_spec);
644 bb.ds = NORMALIZED_SEGMENT((unsigned)&cd_spec);
645 bios(&bb);
646 return bb.eax.r.h;
647}
648
649int readDriveParameters(int drive, struct driveParameters *dp)
650{
651 bb.intno = 0x13;
652 bb.edx.r.l = drive;
653 bb.eax.r.h = 0x08;
654 bios(&bb);
655 if (bb.eax.r.h == 0) {
656 dp->heads = bb.edx.r.h;
657 dp->sectors = bb.ecx.r.l & 0x3F;
658 dp->cylinders = bb.ecx.r.h | ((bb.ecx.r.l & 0xC0) << 2);
659 dp->totalDrives = bb.edx.r.l;
660 } else {
661 bzero(dp, sizeof(*dp));
662 }
663 return bb.eax.r.h;
664
665}
666#endif
667
668#ifdef APM_SUPPORT
669
670#define APM_INTNO 0x15
671#define APM_INTCODE 0x53
672
673int
674APMPresent(void)
675{
676 bb.intno = APM_INTNO;
677 bb.eax.r.h = APM_INTCODE;
678 bb.eax.r.l = 0x00;
679 bb.ebx.rr = 0x0000;
680 bios(&bb);
681 if ((bb.flags.cf == 0) &&
682 (bb.ebx.r.h == 'P') &&
683 (bb.ebx.r.l == 'M')) {
684 /* Success */
685 bootArgs->apmConfig.major_vers = bb.eax.r.h;
686 bootArgs->apmConfig.minor_vers = bb.eax.r.l;
687 bootArgs->apmConfig.flags.data = bb.ecx.rr;
688 return 1;
689 }
690 return 0;
691}
692
693int
694APMConnect32(void)
695{
696 bb.intno = APM_INTNO;
697 bb.eax.r.h = APM_INTCODE;
698 bb.eax.r.l = 0x03;
699 bb.ebx.rr = 0x0000;
700 bios(&bb);
701 if (bb.flags.cf == 0) {
702 /* Success */
703 bootArgs->apmConfig.cs32_base = (bb.eax.rr) << 4;
704 bootArgs->apmConfig.entry_offset = bb.ebx.rx;
705 bootArgs->apmConfig.cs16_base = (bb.ecx.rr) << 4;
706 bootArgs->apmConfig.ds_base = (bb.edx.rr) << 4;
707 if (bootArgs->apmConfig.major_vers >= 1 &&
708 bootArgs->apmConfig.minor_vers >= 1) {
709 bootArgs->apmConfig.cs_length = bb.esi.rr;
710 bootArgs->apmConfig.ds_length = bb.edi.rr;
711 } else {
712 bootArgs->apmConfig.cs_length =
713 bootArgs->apmConfig.ds_length = 64 * 1024;
714 }
715 bootArgs->apmConfig.connected = 1;
716 return 1;
717 }
718 return 0;
719}
720
721#endif /* APM_SUPPORT */
722
723#ifdef EISA_SUPPORT
724bool eisa_present(void)
725{
726 static bool checked = false;
727 static bool isEISA;
728
729 if (!checked) {
730 if (strncmp((char *)0xfffd9, "EISA", 4) == 0)
731 isEISA = true;
732
733 checked = true;
734 }
735
736 return (isEISA);
737}
738
739int
740ReadEISASlotInfo(EISA_slot_info_t *ep, int slot)
741{
742 union {
743 struct {
744 unsigned char char2h :2;
745 unsigned char char1 :5;
746 unsigned char char3 :5;
747 unsigned char char2l :3;
748 unsigned char d2 :4;
749 unsigned char d1 :4;
750 unsigned char d4 :4;
751 unsigned char d3 :4;
752 } s;
753 unsigned char data[4];
754 } u;
755 static char hex[0x10] = "0123456789ABCDEF";
756
757
758 bb.intno = 0x15;
759 bb.eax.r.h = 0xd8;
760 bb.eax.r.l = 0x00;
761 bb.ecx.r.l = slot;
762 bios(&bb);
763 if (bb.flags.cf)
764 return bb.eax.r.h;
765 ep->u_ID.d = bb.eax.r.l;
766 ep->configMajor = bb.ebx.r.h;
767 ep->configMinor = bb.ebx.r.l;
768 ep->checksum = bb.ecx.rr;
769 ep->numFunctions = bb.edx.r.h;
770 ep->u_resources.d = bb.edx.r.l;
771 u.data[0] = bb.edi.r.l;
772 u.data[1] = bb.edi.r.h;
773 u.data[2] = bb.esi.r.l;
774 u.data[3] = bb.esi.r.h;
775 ep->id[0] = u.s.char1 + ('A' - 1);
776 ep->id[1] = (u.s.char2l | (u.s.char2h << 3)) + ('A' - 1);
777 ep->id[2] = u.s.char3 + ('A' - 1);
778 ep->id[3] = hex[u.s.d1];
779 ep->id[4] = hex[u.s.d2];
780 ep->id[5] = hex[u.s.d3];
781 ep->id[6] = hex[u.s.d4];
782 ep->id[7] = 0;
783 return 0;
784}
785
786/*
787 * Note: ep must point to an address below 64k.
788 */
789
790int
791ReadEISAFuncInfo(EISA_func_info_t *ep, int slot, int function)
792{
793 bb.intno = 0x15;
794 bb.eax.r.h = 0xd8;
795 bb.eax.r.l = 0x01;
796 bb.ecx.r.l = slot;
797 bb.ecx.r.h = function;
798 bb.esi.rr = (unsigned int)ep->data;
799 bios(&bb);
800 if (bb.eax.r.h == 0) {
801 ep->slot = slot;
802 ep->function = function;
803 }
804 return bb.eax.r.h;
805}
806#endif /* EISA_SUPPORT */
807
808#define PCI_SIGNATURE 0x20494350 /* "PCI " */
809
810/*int
811ReadPCIBusInfo(PCI_bus_info_t *pp)
812{
813 bb.intno = 0x1a;
814 bb.eax.r.h = 0xb1;
815 bb.eax.r.l = 0x01;
816 bios(&bb);
817 if ((bb.eax.r.h == 0) && (bb.edx.rx == PCI_SIGNATURE)) {
818 pp->BIOSPresent = 1;
819 pp->u_bus.d = bb.eax.r.l;
820 pp->majorVersion = bb.ebx.r.h;
821 pp->minorVersion = bb.ebx.r.l;
822 pp->maxBusNum = bb.ecx.r.l;
823 return 0;
824 }
825 return -1;
826}*/
827
828void sleep(int n)
829{
830 unsigned int endtime = (time18() + 18*n);
831 while (time18() < endtime);
832}
833
834void delay(int ms)
835{
836 bb.intno = 0x15;
837 bb.eax.r.h = 0x86;
838 bb.ecx.rr = ms >> 16;
839 bb.edx.rr = ms & 0xFFFF;
840 bios(&bb);
841}
842
843

Archive Download this file

Revision: 1079