![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to console.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 / openbios / arch / amd64|
Return to console.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / arch / amd64 |
1.1 root 1: /*
2: * Copyright (C) 2003, 2004 Stefan Reinauer
3: *
4: * See the file "COPYING" for further information about
5: * the copyright and warranty status of this work.
6: */
7:
8: #include "config.h"
9: #include "kernel/kernel.h"
10: #include "openbios.h"
11:
12: #ifdef CONFIG_DEBUG_CONSOLE
13:
14: /* ******************************************************************
15: * serial console functions
16: * ****************************************************************** */
17:
18: #ifdef CONFIG_DEBUG_CONSOLE_SERIAL
19:
20: #define RBR(x) x==2?0x2f8:0x3f8
21: #define THR(x) x==2?0x2f8:0x3f8
22: #define IER(x) x==2?0x2f9:0x3f9
23: #define IIR(x) x==2?0x2fa:0x3fa
24: #define LCR(x) x==2?0x2fb:0x3fb
25: #define MCR(x) x==2?0x2fc:0x3fc
26: #define LSR(x) x==2?0x2fd:0x3fd
27: #define MSR(x) x==2?0x2fe:0x3fe
28: #define SCR(x) x==2?0x2ff:0x3ff
29: #define DLL(x) x==2?0x2f8:0x3f8
30: #define DLM(x) x==2?0x2f9:0x3f9
31:
32: static int uart_charav(int port)
33: {
34: if (!port)
35: return -1;
36: return ((inb(LSR(port)) & 1) != 0);
37: }
38:
39: static char uart_getchar(int port)
40: {
41: if (!port)
42: return -1;
43: while (!uart_charav(port));
44: return ((char) inb(RBR(port)) & 0177);
45: }
46:
47: static void uart_putchar(int port, unsigned char c)
48: {
49: if (!port)
50: return;
51: if (c == '\n')
52: uart_putchar(port, '\r');
53: while (!(inb(LSR(port)) & 0x20));
54: outb(c, THR(port));
55: }
56:
57: static void uart_init_line(int port, unsigned long baud)
58: {
59: int i, baudconst;
60:
61: if (!port)
62: return;
63:
64: switch (baud) {
65: case 115200:
66: baudconst = 1;
67: break;
68: case 57600:
69: baudconst = 2;
70: break;
71: case 38400:
72: baudconst = 3;
73: break;
74: case 19200:
75: baudconst = 6;
76: break;
77: case 9600:
78: default:
79: baudconst = 12;
80: break;
81: }
82:
83: outb(0x87, LCR(port));
84: outb(0x00, DLM(port));
85: outb(baudconst, DLL(port));
86: outb(0x07, LCR(port));
87: outb(0x0f, MCR(port));
88:
89: for (i = 10; i > 0; i--) {
90: if (inb(LSR(port)) == (unsigned int) 0)
91: break;
92: inb(RBR(port));
93: }
94: }
95:
96: int uart_init(int port, unsigned long speed)
97: {
98: if (port)
99: uart_init_line(port, speed);
100: return -1;
101: }
102:
103: static void serial_putchar(int c)
104: {
105: uart_putchar(CONFIG_SERIAL_PORT, (unsigned char) (c & 0xff));
106: }
107:
108: static void serial_cls(void)
109: {
110: serial_putchar(27);
111: serial_putchar('[');
112: serial_putchar('H');
113: serial_putchar(27);
114: serial_putchar('[');
115: serial_putchar('J');
116: }
117:
118: #endif
119:
120: /* ******************************************************************
121: * simple polling video/keyboard console functions
122: * ****************************************************************** */
123:
124: #ifdef CONFIG_DEBUG_CONSOLE_VGA
125:
126: /* raw vga text mode */
127: #define COLUMNS 80 /* The number of columns. */
128: #define LINES 25 /* The number of lines. */
129: #define ATTRIBUTE 7 /* The attribute of an character. */
130:
131: #define VGA_BASE 0xB8000 /* The video memory address. */
132:
133: /* VGA Index and Data Registers */
134: #define VGA_REG_INDEX 0x03D4 /* VGA index register */
135: #define VGA_REG_DATA 0x03D5 /* VGA data register */
136:
137: #define VGA_IDX_CURMSL 0x09 /* cursor maximum scan line */
138: #define VGA_IDX_CURSTART 0x0A /* cursor start */
139: #define VGA_IDX_CUREND 0x0B /* cursor end */
140: #define VGA_IDX_CURLO 0x0F /* cursor position (low 8 bits) */
141: #define VGA_IDX_CURHI 0x0E /* cursor position (high 8 bits) */
142:
143: /* Save the X and Y position. */
144: static int xpos, ypos;
145: /* Point to the video memory. */
146: static volatile unsigned char *video = (unsigned char *) VGA_BASE;
147:
148: static void video_initcursor(void)
149: {
150: u8 val;
151: outb(VGA_IDX_CURMSL, VGA_REG_INDEX);
152: val = inb(VGA_REG_DATA) & 0x1f; /* maximum scan line -1 */
153:
154: outb(VGA_IDX_CURSTART, VGA_REG_INDEX);
155: outb(0, VGA_REG_DATA);
156:
157: outb(VGA_IDX_CUREND, VGA_REG_INDEX);
158: outb(val, VGA_REG_DATA);
159: }
160:
161:
162:
163: static void video_poscursor(unsigned int x, unsigned int y)
164: {
165: unsigned short pos;
166:
167: /* Calculate new cursor position as a function of x and y */
168: pos = (y * COLUMNS) + x;
169:
170: /* Output the new position to VGA card */
171: outb(VGA_IDX_CURLO, VGA_REG_INDEX); /* output low 8 bits */
172: outb((u8) (pos), VGA_REG_DATA);
173: outb(VGA_IDX_CURHI, VGA_REG_INDEX); /* output high 8 bits */
174: outb((u8) (pos >> 8), VGA_REG_DATA);
175:
176: };
177:
178:
179: static void video_newline(void)
180: {
181: xpos = 0;
182:
183: if (ypos < LINES - 1) {
184: ypos++;
185: } else {
186: int i;
187: memmove((void *) video, (void *) (video + 2 * COLUMNS),
188: (LINES - 1) * COLUMNS * 2);
189:
190: for (i = ((LINES - 1) * 2 * COLUMNS);
191: i < 2 * COLUMNS * LINES;) {
192: video[i++] = 0;
193: video[i++] = ATTRIBUTE;
194: }
195: }
196:
197: }
198:
199: /* Put the character C on the screen. */
200: static void video_putchar(int c)
201: {
202: int p=1;
203:
204: if (c == '\n' || c == '\r') {
205: video_newline();
206: return;
207: }
208:
209: if (c == '\b') {
210: if (xpos) xpos--;
211: c=' ';
212: p=0;
213: }
214:
215:
216: if (xpos >= COLUMNS)
217: video_newline();
218:
219: *(video + (xpos + ypos * COLUMNS) * 2) = c & 0xFF;
220: *(video + (xpos + ypos * COLUMNS) * 2 + 1) = ATTRIBUTE;
221:
222: if (p)
223: xpos++;
224:
225: video_poscursor(xpos, ypos);
226: }
227:
228: static void video_cls(void)
229: {
230: int i;
231:
232: for (i = 0; i < 2 * COLUMNS * LINES;) {
233: video[i++] = 0;
234: video[i++] = ATTRIBUTE;
235: }
236:
237:
238: xpos = 0;
239: ypos = 0;
240:
241: video_initcursor();
242: video_poscursor(xpos, ypos);
243: }
244:
245: void video_init(void)
246: {
247: video=phys_to_virt((unsigned char*)VGA_BASE);
248: }
249:
250: /*
251: * keyboard driver
252: */
253:
254: static char normal[] = {
255: 0x0, 0x1b, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-',
256: '=', '\b', '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o',
257: 'p', '[', ']', 0xa, 0x0, 'a', 's', 'd', 'f', 'g', 'h', 'j',
258: 'k', 'l', ';', 0x27, 0x60, 0x0, 0x5c, 'z', 'x', 'c', 'v', 'b',
259: 'n', 'm', ',', '.', '/', 0x0, '*', 0x0, ' ', 0x0, 0x0, 0x0,
260: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
261: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, '0', 0x7f
262: };
263:
264: static char shifted[] = {
265: 0x0, 0x1b, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_',
266: '+', '\b', '\t', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O',
267: 'P', '{', '}', 0xa, 0x0, 'A', 'S', 'D', 'F', 'G', 'H', 'J',
268: 'K', 'L', ':', 0x22, '~', 0x0, '|', 'Z', 'X', 'C', 'V', 'B',
269: 'N', 'M', '<', '>', '?', 0x0, '*', 0x0, ' ', 0x0, 0x0, 0x0,
270: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, '7', '8',
271: '9', 0x0, '4', '5', '6', 0x0, '1', '2', '3', '0', 0x7f
272: };
273:
274: static int key_ext;
275: static int key_lshift = 0, key_rshift = 0, key_caps = 0;
276:
277: static char last_key;
278:
279: static void keyboard_cmd(unsigned char cmd, unsigned char val)
280: {
281: outb(cmd, 0x60);
282: /* wait until keyboard controller accepts cmds: */
283: while (inb(0x64) & 2);
284: outb(val, 0x60);
285: while (inb(0x64) & 2);
286: }
287:
288: static char keyboard_poll(void)
289: {
290: unsigned int c;
291: if (inb(0x64) & 1) {
292: c = inb(0x60);
293: switch (c) {
294: case 0xe0:
295: key_ext = 1;
296: return 0;
297: case 0x2a:
298: key_lshift = 1;
299: return 0;
300: case 0x36:
301: key_rshift = 1;
302: return 0;
303: case 0xaa:
304: key_lshift = 0;
305: return 0;
306: case 0xb6:
307: key_rshift = 0;
308: return 0;
309: case 0x3a:
310: if (key_caps) {
311: key_caps = 0;
312: keyboard_cmd(0xed, 0);
313: } else {
314: key_caps = 1;
315: keyboard_cmd(0xed, 4); /* set caps led */
316: }
317: return 0;
318: }
319:
320: if (key_ext) {
321: // void printk(const char *format, ...);
322: printk("extended keycode: %x\n", c);
323:
324: key_ext = 0;
325: return 0;
326: }
327:
328: if (c & 0x80) /* unhandled key release */
329: return 0;
330:
331: if (key_lshift || key_rshift)
332: return key_caps ? normal[c] : shifted[c];
333: else
334: return key_caps ? shifted[c] : normal[c];
335: }
336: return 0;
337: }
338:
339: static int keyboard_dataready(void)
340: {
341: if (last_key)
342: return 1;
343:
344: last_key = keyboard_poll();
345:
346: return (last_key != 0);
347: }
348:
349: static unsigned char keyboard_readdata(void)
350: {
351: char tmp;
352: while (!keyboard_dataready());
353: tmp = last_key;
354: last_key = 0;
355: return tmp;
356: }
357: #endif
358:
359:
360: /* ******************************************************************
361: * common functions, implementing simple concurrent console
362: * ****************************************************************** */
363:
364: int putchar(int c)
365: {
366: #ifdef CONFIG_DEBUG_CONSOLE_SERIAL
367: serial_putchar(c);
368: #endif
369: #ifdef CONFIG_DEBUG_CONSOLE_VGA
370: video_putchar(c);
371: #endif
372: return c;
373: }
374:
375: int availchar(void)
376: {
377: #ifdef CONFIG_DEBUG_CONSOLE_SERIAL
378: if (uart_charav(CONFIG_SERIAL_PORT))
379: return 1;
380: #endif
381: #ifdef CONFIG_DEBUG_CONSOLE_VGA
382: if (keyboard_dataready())
383: return 1;
384: #endif
385: return 0;
386: }
387:
388: int getchar(void)
389: {
390: #ifdef CONFIG_DEBUG_CONSOLE_SERIAL
391: if (uart_charav(CONFIG_SERIAL_PORT))
392: return (uart_getchar(CONFIG_SERIAL_PORT));
393: #endif
394: #ifdef CONFIG_DEBUG_CONSOLE_VGA
395: if (keyboard_dataready())
396: return (keyboard_readdata());
397: #endif
398: return 0;
399: }
400:
401: void cls(void)
402: {
403: #ifdef CONFIG_DEBUG_CONSOLE_SERIAL
404: serial_cls();
405: #endif
406: #ifdef CONFIG_DEBUG_CONSOLE_VGA
407: video_cls();
408: #endif
409: }
410:
411:
412: #endif // CONFIG_DEBUG_CONSOLE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.