![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vbe.c 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 / vgasrc|
Return to vbe.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / vgasrc |
1.1 root 1: // Video Bios Extensions handlers
2: //
3: // Copyright (C) 2012 Kevin O'Connor <[email protected]>
4: // Copyright (C) 2011 Julian Pidancet <[email protected]>
5: // Copyright (C) 2001-2008 the LGPL VGABios developers Team
6: //
7: // This file may be distributed under the terms of the GNU LGPLv3 license.
8:
9: #include "vgabios.h" // handle_104f
10: #include "config.h" // CONFIG_*
11: #include "bregs.h" // struct bregs
12: #include "vbe.h" // struct vbe_info
13: #include "util.h" // dprintf
14: #include "biosvar.h" // GET_GLOBAL
15: #include "vgahw.h" // vgahw_set_mode
16:
17: u32 VBE_total_memory VAR16 = 256 * 1024;
18: u32 VBE_capabilities VAR16;
19: u32 VBE_framebuffer VAR16;
20: u16 VBE_win_granularity VAR16 = 64;
21:
22: static void
23: vbe_104f00(struct bregs *regs)
24: {
25: u16 seg = regs->es;
26: struct vbe_info *info = (void*)(regs->di+0);
27:
28: if (GET_FARVAR(seg, info->signature) == VBE2_SIGNATURE) {
29: dprintf(4, "Get VBE Controller: VBE2 Signature found\n");
30: } else if (GET_FARVAR(seg, info->signature) == VESA_SIGNATURE) {
31: dprintf(4, "Get VBE Controller: VESA Signature found\n");
32: } else {
33: dprintf(4, "Get VBE Controller: Invalid Signature\n");
34: }
35:
36: memset_far(seg, info, 0, sizeof(*info));
37:
38: SET_FARVAR(seg, info->signature, VESA_SIGNATURE);
39:
40: SET_FARVAR(seg, info->version, 0x0300);
41:
42: SET_FARVAR(seg, info->oem_string,
43: SEGOFF(get_global_seg(), (u32)VBE_OEM_STRING));
44: SET_FARVAR(seg, info->capabilities, GET_GLOBAL(VBE_capabilities));
45:
46: /* We generate our mode list in the reserved field of the info block */
47: u16 *destmode = (void*)info->reserved;
48: SET_FARVAR(seg, info->video_mode, SEGOFF(seg, (u32)destmode));
49:
50: /* Total memory (in 64k blocks) */
51: SET_FARVAR(seg, info->total_memory
52: , GET_GLOBAL(VBE_total_memory) / (64*1024));
53:
54: SET_FARVAR(seg, info->oem_vendor_string,
55: SEGOFF(get_global_seg(), (u32)VBE_VENDOR_STRING));
56: SET_FARVAR(seg, info->oem_product_string,
57: SEGOFF(get_global_seg(), (u32)VBE_PRODUCT_STRING));
58: SET_FARVAR(seg, info->oem_revision_string,
59: SEGOFF(get_global_seg(), (u32)VBE_REVISION_STRING));
60:
61: /* Fill list of modes */
62: u16 *last = (void*)&info->reserved[sizeof(info->reserved)];
63: vgahw_list_modes(seg, destmode, last - 1);
64:
65: regs->ax = 0x004f;
66: }
67:
68: static void
69: vbe_104f01(struct bregs *regs)
70: {
71: u16 seg = regs->es;
72: struct vbe_mode_info *info = (void*)(regs->di+0);
73: u16 mode = regs->cx;
74:
75: dprintf(1, "VBE mode info request: %x\n", mode);
76:
77: struct vgamode_s *vmode_g = vgahw_find_mode(mode);
78: if (! vmode_g) {
79: dprintf(1, "VBE mode %x not found\n", mode);
80: regs->ax = 0x014f;
81: return;
82: }
83:
84: memset_far(seg, info, 0, sizeof(*info));
85: u16 mode_attr = VBE_MODE_ATTRIBUTE_SUPPORTED |
86: VBE_MODE_ATTRIBUTE_EXTENDED_INFORMATION_AVAILABLE |
87: VBE_MODE_ATTRIBUTE_COLOR_MODE |
88: VBE_MODE_ATTRIBUTE_GRAPHICS_MODE |
89: VBE_MODE_ATTRIBUTE_NOT_VGA_COMPATIBLE;
90: u32 framebuffer = GET_GLOBAL(VBE_framebuffer);
91: if (framebuffer)
92: mode_attr |= VBE_MODE_ATTRIBUTE_LINEAR_FRAME_BUFFER_MODE;
93: SET_FARVAR(seg, info->mode_attributes, mode_attr);
94: SET_FARVAR(seg, info->winA_attributes,
95: VBE_WINDOW_ATTRIBUTE_RELOCATABLE |
96: VBE_WINDOW_ATTRIBUTE_READABLE |
97: VBE_WINDOW_ATTRIBUTE_WRITEABLE);
98: SET_FARVAR(seg, info->winB_attributes, 0);
99: SET_FARVAR(seg, info->win_granularity, GET_GLOBAL(VBE_win_granularity));
100: SET_FARVAR(seg, info->win_size, 64); /* Bank size 64K */
101: SET_FARVAR(seg, info->winA_seg, GET_GLOBAL(vmode_g->sstart));
102: SET_FARVAR(seg, info->winB_seg, 0x0);
103: extern void entry_104f05(void);
104: SET_FARVAR(seg, info->win_func_ptr
105: , SEGOFF(get_global_seg(), (u32)entry_104f05));
106: int width = GET_GLOBAL(vmode_g->width);
107: int height = GET_GLOBAL(vmode_g->height);
108: int linesize = DIV_ROUND_UP(width * vga_bpp(vmode_g), 8);
109: SET_FARVAR(seg, info->bytes_per_scanline, linesize);
110: SET_FARVAR(seg, info->xres, width);
111: SET_FARVAR(seg, info->yres, height);
112: SET_FARVAR(seg, info->xcharsize, GET_GLOBAL(vmode_g->cwidth));
113: SET_FARVAR(seg, info->ycharsize, GET_GLOBAL(vmode_g->cheight));
114: int depth = GET_GLOBAL(vmode_g->depth);
115: int planes = (depth == 4) ? 4 : 1;
116: SET_FARVAR(seg, info->planes, planes);
117: SET_FARVAR(seg, info->bits_per_pixel, depth);
118: SET_FARVAR(seg, info->banks, 1);
119: SET_FARVAR(seg, info->mem_model, GET_GLOBAL(vmode_g->memmodel));
120: SET_FARVAR(seg, info->bank_size, 0);
121: u32 pages = GET_GLOBAL(VBE_total_memory) / ALIGN(height * linesize, 64*1024);
122: SET_FARVAR(seg, info->pages, (pages / planes) - 1);
123: SET_FARVAR(seg, info->reserved0, 1);
124:
125: u8 r_size, r_pos, g_size, g_pos, b_size, b_pos, a_size, a_pos;
126:
127: switch (depth) {
128: case 15: r_size = 5; r_pos = 10; g_size = 5; g_pos = 5;
129: b_size = 5; b_pos = 0; a_size = 1; a_pos = 15; break;
130: case 16: r_size = 5; r_pos = 11; g_size = 6; g_pos = 5;
131: b_size = 5; b_pos = 0; a_size = 0; a_pos = 0; break;
132: case 24: r_size = 8; r_pos = 16; g_size = 8; g_pos = 8;
133: b_size = 8; b_pos = 0; a_size = 0; a_pos = 0; break;
134: case 32: r_size = 8; r_pos = 16; g_size = 8; g_pos = 8;
135: b_size = 8; b_pos = 0; a_size = 8; a_pos = 24; break;
136: default: r_size = 0; r_pos = 0; g_size = 0; g_pos = 0;
137: b_size = 0; b_pos = 0; a_size = 0; a_pos = 0; break;
138: }
139:
140: SET_FARVAR(seg, info->red_size, r_size);
141: SET_FARVAR(seg, info->red_pos, r_pos);
142: SET_FARVAR(seg, info->green_size, g_size);
143: SET_FARVAR(seg, info->green_pos, g_pos);
144: SET_FARVAR(seg, info->blue_size, b_size);
145: SET_FARVAR(seg, info->blue_pos, b_pos);
146: SET_FARVAR(seg, info->alpha_size, a_size);
147: SET_FARVAR(seg, info->alpha_pos, a_pos);
148:
149: if (depth == 32)
150: SET_FARVAR(seg, info->directcolor_info,
151: VBE_DIRECTCOLOR_RESERVED_BITS_AVAILABLE);
152: else
153: SET_FARVAR(seg, info->directcolor_info, 0);
154:
155: if (depth > 4)
156: SET_FARVAR(seg, info->phys_base, GET_GLOBAL(VBE_framebuffer));
157: else
158: SET_FARVAR(seg, info->phys_base, 0);
159:
160: SET_FARVAR(seg, info->reserved1, 0);
161: SET_FARVAR(seg, info->reserved2, 0);
162: SET_FARVAR(seg, info->linear_bytes_per_scanline, linesize);
163: SET_FARVAR(seg, info->bank_pages, 0);
164: SET_FARVAR(seg, info->linear_pages, 0);
165: SET_FARVAR(seg, info->linear_red_size, r_size);
166: SET_FARVAR(seg, info->linear_red_pos, r_pos);
167: SET_FARVAR(seg, info->linear_green_size, g_size);
168: SET_FARVAR(seg, info->linear_green_pos, g_pos);
169: SET_FARVAR(seg, info->linear_blue_size, b_size);
170: SET_FARVAR(seg, info->linear_blue_pos, b_pos);
171: SET_FARVAR(seg, info->linear_alpha_size, a_size);
172: SET_FARVAR(seg, info->linear_alpha_pos, a_pos);
173: SET_FARVAR(seg, info->pixclock_max, 0);
174:
175: regs->ax = 0x004f;
176: }
177:
178: static void
179: vbe_104f02(struct bregs *regs)
180: {
181: dprintf(1, "VBE mode set: %x\n", regs->bx);
182:
183: int mode = regs->bx & ~MF_VBEFLAGS;
184: int flags = regs->bx & MF_VBEFLAGS;
185: int ret = vga_set_mode(mode, flags);
186:
187: regs->ah = ret;
188: regs->al = 0x4f;
189: }
190:
191: static void
192: vbe_104f03(struct bregs *regs)
193: {
194: regs->bx = GET_BDA(vbe_mode);
195: dprintf(1, "VBE current mode=%x\n", regs->bx);
196: regs->ax = 0x004f;
197: }
198:
199: static void
200: vbe_104f04(struct bregs *regs)
201: {
202: u16 seg = regs->es;
203: void *data = (void*)(regs->bx+0);
204: u16 states = regs->cx;
205: if (states & ~0x0f)
206: goto fail;
207: int ret;
208: switch (regs->dl) {
209: case 0x00:
210: ret = vgahw_size_state(states);
211: if (ret < 0)
212: goto fail;
213: regs->bx = ret / 64;
214: break;
215: case 0x01:
216: ret = vgahw_save_state(seg, data, states);
217: if (ret)
218: goto fail;
219: break;
220: case 0x02:
221: ret = vgahw_restore_state(seg, data, states);
222: if (ret)
223: goto fail;
224: break;
225: default:
226: goto fail;
227: }
228: regs->ax = 0x004f;
229: return;
230: fail:
231: regs->ax = 0x014f;
232: }
233:
234: void VISIBLE16
235: vbe_104f05(struct bregs *regs)
236: {
237: if (regs->bh > 1 || regs->bl > 1)
238: goto fail;
239: if (GET_BDA(vbe_mode) & MF_LINEARFB) {
240: regs->ah = VBE_RETURN_STATUS_INVALID;
241: return;
242: }
243: struct vgamode_s *vmode_g = get_current_mode();
244: if (! vmode_g)
245: goto fail;
246: if (regs->bh) {
247: int ret = vgahw_get_window(vmode_g, regs->bl);
248: if (ret < 0)
249: goto fail;
250: regs->dx = ret;
251: regs->ax = 0x004f;
252: return;
253: }
254: int ret = vgahw_set_window(vmode_g, regs->bl, regs->dx);
255: if (ret)
256: goto fail;
257: regs->ax = 0x004f;
258: return;
259: fail:
260: regs->ax = 0x014f;
261: }
262:
263: static void
264: vbe_104f06(struct bregs *regs)
265: {
266: if (regs->bl > 0x02)
267: goto fail;
268: struct vgamode_s *vmode_g = get_current_mode();
269: if (! vmode_g)
270: goto fail;
271: int bpp = vga_bpp(vmode_g);
272:
273: if (regs->bl == 0x00) {
274: int ret = vgahw_set_linelength(vmode_g, DIV_ROUND_UP(regs->cx * bpp, 8));
275: if (ret)
276: goto fail;
277: } else if (regs->bl == 0x02) {
278: int ret = vgahw_set_linelength(vmode_g, regs->cx);
279: if (ret)
280: goto fail;
281: }
282: int linelength = vgahw_get_linelength(vmode_g);
283: if (linelength < 0)
284: goto fail;
285:
286: regs->bx = linelength;
287: regs->cx = (linelength * 8) / bpp;
288: regs->dx = GET_GLOBAL(VBE_total_memory) / linelength;
289: regs->ax = 0x004f;
290: return;
291: fail:
292: regs->ax = 0x014f;
293: }
294:
295: static void
296: vbe_104f07(struct bregs *regs)
297: {
298: struct vgamode_s *vmode_g = get_current_mode();
299: if (! vmode_g)
300: goto fail;
301: int bpp = vga_bpp(vmode_g);
302: int linelength = vgahw_get_linelength(vmode_g);
303: if (linelength < 0)
304: goto fail;
305:
306: int ret;
307: switch (regs->bl) {
308: case 0x80:
309: case 0x00:
310: ret = vgahw_set_displaystart(
311: vmode_g, DIV_ROUND_UP(regs->cx * bpp, 8) + linelength * regs->dx);
312: if (ret)
313: goto fail;
314: break;
315: case 0x01:
316: ret = vgahw_get_displaystart(vmode_g);
317: if (ret < 0)
318: goto fail;
319: regs->dx = ret / linelength;
320: regs->cx = (ret % linelength) * 8 / bpp;
321: break;
322: default:
323: goto fail;
324: }
325: regs->ax = 0x004f;
326: return;
327: fail:
328: regs->ax = 0x014f;
329: }
330:
331: static void
332: vbe_104f08(struct bregs *regs)
333: {
334: struct vgamode_s *vmode_g = get_current_mode();
335: if (! vmode_g)
336: goto fail;
337: u8 memmodel = GET_GLOBAL(vmode_g->memmodel);
338: if (memmodel == MM_DIRECT || memmodel == MM_YUV) {
339: regs->ax = 0x034f;
340: return;
341: }
342: if (regs->bl > 1)
343: goto fail;
344: if (regs->bl == 0) {
345: int ret = vgahw_set_dacformat(vmode_g, regs->bh);
346: if (ret < 0)
347: goto fail;
348: }
349: int ret = vgahw_get_dacformat(vmode_g);
350: if (ret < 0)
351: goto fail;
352: regs->bh = ret;
353: regs->ax = 0x004f;
354: return;
355: fail:
356: regs->ax = 0x014f;
357: }
358:
359: static void
360: vbe_104f0a(struct bregs *regs)
361: {
362: debug_stub(regs);
363: regs->ax = 0x0100;
364: }
365:
366: static void
367: vbe_104f10(struct bregs *regs)
368: {
369: switch (regs->bl) {
370: case 0x00:
371: regs->bx = 0x0f30;
372: break;
373: case 0x01:
374: SET_BDA(vbe_flag, regs->bh);
375: break;
376: case 0x02:
377: regs->bh = GET_BDA(vbe_flag);
378: break;
379: default:
380: regs->ax = 0x014f;
381: return;
382: }
383: regs->ax = 0x004f;
384: }
385:
386: static void
387: vbe_104fXX(struct bregs *regs)
388: {
389: debug_stub(regs);
390: regs->ax = 0x0100;
391: }
392:
393: void noinline
394: handle_104f(struct bregs *regs)
395: {
396: if (!CONFIG_VGA_VBE) {
397: vbe_104fXX(regs);
398: return;
399: }
400:
401: switch (regs->al) {
402: case 0x00: vbe_104f00(regs); break;
403: case 0x01: vbe_104f01(regs); break;
404: case 0x02: vbe_104f02(regs); break;
405: case 0x03: vbe_104f03(regs); break;
406: case 0x04: vbe_104f04(regs); break;
407: case 0x05: vbe_104f05(regs); break;
408: case 0x06: vbe_104f06(regs); break;
409: case 0x07: vbe_104f07(regs); break;
410: case 0x08: vbe_104f08(regs); break;
411: case 0x0a: vbe_104f0a(regs); break;
412: case 0x10: vbe_104f10(regs); break;
413: default: vbe_104fXX(regs); break;
414: }
415: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.