![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to biosvar.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src|
Return to biosvar.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src |
1.1 root 1: // Variable layouts of bios.
2: //
1.1.1.4 ! root 3: // Copyright (C) 2008-2010 Kevin O'Connor <[email protected]>
1.1 root 4: //
5: // This file may be distributed under the terms of the GNU LGPLv3 license.
6: #ifndef __BIOSVAR_H
7: #define __BIOSVAR_H
8:
9: #include "types.h" // u8
10: #include "farptr.h" // GET_FARVAR
11: #include "config.h" // CONFIG_*
12: #include "disk.h" // struct chs_s
13:
14:
15: /****************************************************************
16: * Interupt vector table
17: ****************************************************************/
18:
19: struct rmode_IVT {
20: struct segoff_s ivec[256];
21: };
22:
23: #define GET_IVT(vector) \
24: GET_FARVAR(SEG_IVT, ((struct rmode_IVT *)0)->ivec[vector])
25: #define SET_IVT(vector, segoff) \
26: SET_FARVAR(SEG_IVT, ((struct rmode_IVT *)0)->ivec[vector], segoff)
27:
1.1.1.4 ! root 28: #define FUNC16(func) ({ \
! 29: ASSERT32FLAT(); \
! 30: extern void func (void); \
! 31: SEGOFF(SEG_BIOS, (u32)func - BUILD_BIOS_ADDR); \
! 32: })
! 33:
1.1 root 34:
35: /****************************************************************
36: * Bios Data Area (BDA)
37: ****************************************************************/
38:
39: struct bios_data_area_s {
40: // 40:00
41: u16 port_com[4];
42: u16 port_lpt[3];
43: u16 ebda_seg;
44: // 40:10
45: u16 equipment_list_flags;
46: u8 pad1;
47: u16 mem_size_kb;
48: u8 pad2;
49: u8 ps2_ctrl_flag;
50: u8 kbd_flag0;
51: u8 kbd_flag1;
52: u8 alt_keypad;
53: u16 kbd_buf_head;
54: u16 kbd_buf_tail;
55: // 40:1e
56: u8 kbd_buf[32];
57: u8 floppy_recalibration_status;
58: u8 floppy_motor_status;
59: // 40:40
60: u8 floppy_motor_counter;
61: u8 floppy_last_status;
62: u8 floppy_return_status[7];
63: u8 video_mode;
64: u16 video_cols;
65: u16 video_pagesize;
66: u16 video_pagestart;
67: // 40:50
68: u16 cursor_pos[8];
69: // 40:60
70: u16 cursor_type;
71: u8 video_page;
72: u16 crtc_address;
73: u8 video_msr;
74: u8 video_pal;
75: struct segoff_s jump;
76: u8 other_6b;
77: u32 timer_counter;
78: // 40:70
79: u8 timer_rollover;
80: u8 break_flag;
81: u16 soft_reset_flag;
82: u8 disk_last_status;
83: u8 hdcount;
84: u8 disk_control_byte;
85: u8 port_disk;
86: u8 lpt_timeout[4];
87: u8 com_timeout[4];
88: // 40:80
89: u16 kbd_buf_start_offset;
90: u16 kbd_buf_end_offset;
91: u8 video_rows;
92: u16 char_height;
93: u8 video_ctl;
94: u8 video_switches;
95: u8 modeset_ctl;
96: u8 dcc_index;
97: u8 floppy_last_data_rate;
98: u8 disk_status_controller;
99: u8 disk_error_controller;
100: u8 disk_interrupt_flag;
101: u8 floppy_harddisk_info;
102: // 40:90
103: u8 floppy_media_state[4];
104: u8 floppy_track[2];
105: u8 kbd_flag2;
106: u8 kbd_led;
107: struct segoff_s user_wait_complete_flag;
108: u32 user_wait_timeout;
109: // 40:A0
110: u8 rtc_wait_flag;
111: u8 other_a1[7];
112: struct segoff_s video_savetable;
113: u8 other_ac[4];
114: // 40:B0
115: u8 other_b0[10];
116: u16 vbe_mode;
117: } PACKED;
118:
119: // BDA floppy_recalibration_status bitdefs
120: #define FRS_TIMEOUT (1<<7)
121:
122: // BDA rtc_wait_flag bitdefs
123: #define RWS_WAIT_PENDING (1<<0)
124: #define RWS_WAIT_ELAPSED (1<<7)
125:
126: // BDA floppy_media_state bitdefs
127: #define FMS_DRIVE_STATE_MASK (0x07)
128: #define FMS_MEDIA_DRIVE_ESTABLISHED (1<<4)
129: #define FMS_DOUBLE_STEPPING (1<<5)
130: #define FMS_DATA_RATE_MASK (0xc0)
131:
132: // Accessor functions
133: #define GET_BDA(var) \
134: GET_FARVAR(SEG_BDA, ((struct bios_data_area_s *)0)->var)
135: #define SET_BDA(var, val) \
136: SET_FARVAR(SEG_BDA, ((struct bios_data_area_s *)0)->var, (val))
137: #define CLEARBITS_BDA(var, val) do { \
138: typeof(((struct bios_data_area_s *)0)->var) __val = GET_BDA(var); \
139: SET_BDA(var, (__val & ~(val))); \
140: } while (0)
141: #define SETBITS_BDA(var, val) do { \
142: typeof(((struct bios_data_area_s *)0)->var) __val = GET_BDA(var); \
143: SET_BDA(var, (__val | (val))); \
144: } while (0)
145:
146:
147: /****************************************************************
148: * Extended Bios Data Area (EBDA)
149: ****************************************************************/
150:
151: // DPTE definition
152: struct dpte_s {
153: u16 iobase1;
154: u16 iobase2;
155: u8 prefix;
156: u8 unused;
157: u8 irq;
158: u8 blkcount;
159: u8 dma;
160: u8 pio;
161: u16 options;
162: u16 reserved;
163: u8 revision;
164: u8 checksum;
165: };
166:
167: // ElTorito Device Emulation data
168: struct cdemu_s {
1.1.1.3 root 169: struct drive_s *emulated_drive_gf;
1.1 root 170: u32 ilba;
171: u16 buffer_segment;
172: u16 load_segment;
173: u16 sector_count;
174: u8 active;
175: u8 media;
176: u8 emulated_extdrive;
177:
178: // Virtual device
179: struct chs_s lchs;
180: };
181:
182: struct fdpt_s {
183: u16 cylinders;
184: u8 heads;
185: u8 a0h_signature;
186: u8 phys_sectors;
187: u16 precompensation;
188: u8 reserved;
189: u8 drive_control_byte;
190: u16 phys_cylinders;
191: u8 phys_heads;
192: u16 landing_zone;
193: u8 sectors;
194: u8 checksum;
195: } PACKED;
196:
1.1.1.3 root 197: struct usbkeyinfo {
198: union {
199: struct {
200: u8 modifiers;
201: u8 repeatcount;
202: u8 keys[6];
203: };
204: u64 data;
205: };
206: };
207:
1.1 root 208: struct extended_bios_data_area_s {
209: u8 size;
210: u8 reserved1[0x21];
211: struct segoff_s far_call_pointer;
212: u8 mouse_flag1;
213: u8 mouse_flag2;
214: u8 mouse_data[0x08];
215: // 0x30
216: u8 other1[0x0d];
217:
218: // 0x3d
219: struct fdpt_s fdpt[2];
220:
221: // 0x5d
222: u8 other2[0xC4];
223:
224: // 0x121 - Begin custom storage.
225: u8 ps2ctr;
1.1.1.3 root 226: struct usbkeyinfo usbkey_last;
227:
1.1 root 228: int RTCusers;
229:
230: // El Torito Emulation data
231: struct cdemu_s cdemu;
232:
233: // Buffer for disk DPTE table
234: struct dpte_s dpte;
235:
236: // Locks for removable devices
237: u8 cdrom_locks[CONFIG_MAX_EXTDRIVE];
238:
239: u16 boot_sequence;
240:
241: // Stack space available for code that needs it.
242: u8 extra_stack[512] __aligned(8);
243: } PACKED;
244:
245: // The initial size and location of EBDA
246: #define EBDA_SIZE_START \
247: DIV_ROUND_UP(sizeof(struct extended_bios_data_area_s), 1024)
248: #define EBDA_SEGMENT_START \
249: FLATPTR_TO_SEG(BUILD_LOWRAM_END - EBDA_SIZE_START*1024)
250:
251: // Accessor functions
1.1.1.2 root 252: static inline u16 get_ebda_seg(void) {
1.1 root 253: return GET_BDA(ebda_seg);
254: }
255: static inline struct extended_bios_data_area_s *
1.1.1.2 root 256: get_ebda_ptr(void)
1.1 root 257: {
1.1.1.2 root 258: ASSERT32FLAT();
1.1 root 259: return MAKE_FLATPTR(get_ebda_seg(), 0);
260: }
261: #define GET_EBDA2(eseg, var) \
262: GET_FARVAR(eseg, ((struct extended_bios_data_area_s *)0)->var)
263: #define SET_EBDA2(eseg, var, val) \
264: SET_FARVAR(eseg, ((struct extended_bios_data_area_s *)0)->var, (val))
265: #define GET_EBDA(var) \
266: GET_EBDA2(get_ebda_seg(), var)
267: #define SET_EBDA(var, val) \
268: SET_EBDA2(get_ebda_seg(), var, (val))
269:
270: #define EBDA_OFFSET_TOP_STACK \
271: offsetof(struct extended_bios_data_area_s, extra_stack[ \
272: FIELD_SIZEOF(struct extended_bios_data_area_s \
273: , extra_stack)])
274:
275:
276: /****************************************************************
277: * Global variables
278: ****************************************************************/
279:
1.1.1.2 root 280: #if MODE16 == 0 && MODESEGMENT == 1
281: // In 32bit segmented mode %cs may not be readable and the code may be
282: // relocated. The entry code sets up %gs with a readable segment and
283: // the code offset can be determined by get_global_offset().
284: #define GLOBAL_SEGREG GS
285: static inline u32 __attribute_const get_global_offset(void) {
286: u32 ret;
287: asm(" calll 1f\n"
288: "1:popl %0\n"
289: " subl $1b, %0"
290: : "=r"(ret));
291: return ret;
292: }
293: #else
1.1 root 294: #define GLOBAL_SEGREG CS
1.1.1.2 root 295: static inline u32 __attribute_const get_global_offset(void) {
296: return 0;
297: }
298: #endif
299: static inline u16 get_global_seg(void) {
1.1 root 300: return GET_SEG(GLOBAL_SEGREG);
301: }
1.1.1.2 root 302: #define GET_GLOBAL(var) \
303: GET_VAR(GLOBAL_SEGREG, *(typeof(&(var)))((void*)&(var) \
304: + get_global_offset()))
1.1 root 305: #define SET_GLOBAL(var, val) do { \
1.1.1.2 root 306: ASSERT32FLAT(); \
1.1 root 307: (var) = (val); \
308: } while (0)
1.1.1.2 root 309: #if MODESEGMENT
1.1.1.3 root 310: #define GLOBALFLAT2GLOBAL(var) ((typeof(var))((void*)(var) - BUILD_BIOS_ADDR))
1.1 root 311: #else
1.1.1.3 root 312: #define GLOBALFLAT2GLOBAL(var) (var)
1.1 root 313: #endif
1.1.1.3 root 314: // Access a "flat" pointer known to point to the f-segment.
315: #define GET_GLOBALFLAT(var) GET_GLOBAL(*GLOBALFLAT2GLOBAL(&(var)))
1.1 root 316:
317:
318: /****************************************************************
319: * Bios Config Table
320: ****************************************************************/
321:
322: struct bios_config_table_s {
323: u16 size;
324: u8 model;
325: u8 submodel;
326: u8 biosrev;
327: u8 feature1, feature2, feature3, feature4, feature5;
328: } PACKED;
329:
330: extern struct bios_config_table_s BIOS_CONFIG_TABLE __aligned(1);
331:
332: #endif // __BIOSVAR_H
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.