1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/types.h>
30#include <linux/fs.h>
31#include <linux/kernel.h>
32#include <linux/module.h>
33#include <linux/console.h>
34#include <linux/string.h>
35#include <linux/kd.h>
36#include <linux/slab.h>
37#include <linux/vt_kern.h>
38#include <linux/vt_buffer.h>
39#include <linux/selection.h>
40#include <linux/spinlock.h>
41#include <linux/ioport.h>
42#include <linux/delay.h>
43#include <linux/init.h>
44
45#include <asm/io.h>
46#include <asm/vga.h>
47
48static DEFINE_SPINLOCK(mda_lock);
49
50
51
52static unsigned long mda_vram_base;
53static unsigned long mda_vram_len;
54static unsigned int mda_num_columns;
55static unsigned int mda_num_lines;
56
57static unsigned int mda_index_port;
58static unsigned int mda_value_port;
59static unsigned int mda_mode_port;
60static unsigned int mda_status_port;
61static unsigned int mda_gfx_port;
62
63
64
65static int mda_cursor_loc=-1;
66static int mda_cursor_size_from=-1;
67static int mda_cursor_size_to=-1;
68
69static enum { TYPE_MDA, TYPE_HERC, TYPE_HERCPLUS, TYPE_HERCCOLOR } mda_type;
70static char *mda_type_name;
71
72
73
74static int mda_first_vc = 13;
75static int mda_last_vc = 16;
76
77static struct vc_data *mda_display_fg = NULL;
78
79module_param(mda_first_vc, int, 0);
80MODULE_PARM_DESC(mda_first_vc, "First virtual console. Default: 13");
81module_param(mda_last_vc, int, 0);
82MODULE_PARM_DESC(mda_last_vc, "Last virtual console. Default: 16");
83
84
85
86
87#define MDA_CURSOR_BLINKING 0x00
88#define MDA_CURSOR_OFF 0x20
89#define MDA_CURSOR_SLOWBLINK 0x60
90
91#define MDA_MODE_GRAPHICS 0x02
92#define MDA_MODE_VIDEO_EN 0x08
93#define MDA_MODE_BLINK_EN 0x20
94#define MDA_MODE_GFX_PAGE1 0x80
95
96#define MDA_STATUS_HSYNC 0x01
97#define MDA_STATUS_VSYNC 0x80
98#define MDA_STATUS_VIDEO 0x08
99
100#define MDA_CONFIG_COL132 0x08
101#define MDA_GFX_MODE_EN 0x01
102#define MDA_GFX_PAGE_EN 0x02
103
104
105
106
107
108
109static void write_mda_b(unsigned int val, unsigned char reg)
110{
111 unsigned long flags;
112
113 spin_lock_irqsave(&mda_lock, flags);
114
115 outb_p(reg, mda_index_port);
116 outb_p(val, mda_value_port);
117
118 spin_unlock_irqrestore(&mda_lock, flags);
119}
120
121static void write_mda_w(unsigned int val, unsigned char reg)
122{
123 unsigned long flags;
124
125 spin_lock_irqsave(&mda_lock, flags);
126
127 outb_p(reg, mda_index_port); outb_p(val >> 8, mda_value_port);
128 outb_p(reg+1, mda_index_port); outb_p(val & 0xff, mda_value_port);
129
130 spin_unlock_irqrestore(&mda_lock, flags);
131}
132
133#ifdef TEST_MDA_B
134static int test_mda_b(unsigned char val, unsigned char reg)
135{
136 unsigned long flags;
137
138 spin_lock_irqsave(&mda_lock, flags);
139
140 outb_p(reg, mda_index_port);
141 outb (val, mda_value_port);
142
143 udelay(20); val = (inb_p(mda_value_port) == val);
144
145 spin_unlock_irqrestore(&mda_lock, flags);
146 return val;
147}
148#endif
149
150static inline void mda_set_cursor(unsigned int location)
151{
152 if (mda_cursor_loc == location)
153 return;
154
155 write_mda_w(location >> 1, 0x0e);
156
157 mda_cursor_loc = location;
158}
159
160static inline void mda_set_cursor_size(int from, int to)
161{
162 if (mda_cursor_size_from==from && mda_cursor_size_to==to)
163 return;
164
165 if (from > to) {
166 write_mda_b(MDA_CURSOR_OFF, 0x0a);
167 } else {
168 write_mda_b(from, 0x0a);
169 write_mda_b(to, 0x0b);
170 }
171
172 mda_cursor_size_from = from;
173 mda_cursor_size_to = to;
174}
175
176
177#ifndef MODULE
178static int __init mdacon_setup(char *str)
179{
180
181
182 int ints[3];
183
184 str = get_options(str, ARRAY_SIZE(ints), ints);
185
186 if (ints[0] < 2)
187 return 0;
188
189 if (ints[1] < 1 || ints[1] > MAX_NR_CONSOLES ||
190 ints[2] < 1 || ints[2] > MAX_NR_CONSOLES)
191 return 0;
192
193 mda_first_vc = ints[1];
194 mda_last_vc = ints[2];
195 return 1;
196}
197
198__setup("mdacon=", mdacon_setup);
199#endif
200
201static int mda_detect(void)
202{
203 int count=0;
204 u16 *p, p_save;
205 u16 *q, q_save;
206
207
208
209 p = (u16 *) mda_vram_base;
210 q = (u16 *) (mda_vram_base + 0x01000);
211
212 p_save = scr_readw(p); q_save = scr_readw(q);
213
214 scr_writew(0xAA55, p); if (scr_readw(p) == 0xAA55) count++;
215 scr_writew(0x55AA, p); if (scr_readw(p) == 0x55AA) count++;
216 scr_writew(p_save, p);
217
218 if (count != 2) {
219 return 0;
220 }
221
222
223
224 scr_writew(0xA55A, q); scr_writew(0x0000, p);
225 if (scr_readw(q) == 0xA55A) count++;
226
227 scr_writew(0x5AA5, q); scr_writew(0x0000, p);
228 if (scr_readw(q) == 0x5AA5) count++;
229
230 scr_writew(p_save, p); scr_writew(q_save, q);
231
232 if (count == 4) {
233 mda_vram_len = 0x02000;
234 }
235
236
237
238
239
240#ifdef TEST_MDA_B
241
242
243
244 if (! test_mda_b(0x66, 0x0f)) {
245 return 0;
246 }
247
248
249 if (! test_mda_b(0x99, 0x0f)) {
250 return 0;
251 }
252#endif
253
254
255
256
257
258
259 p_save = q_save = inb_p(mda_status_port) & MDA_STATUS_VSYNC;
260
261 for (count=0; count < 50000 && p_save == q_save; count++) {
262 q_save = inb(mda_status_port) & MDA_STATUS_VSYNC;
263 udelay(2);
264 }
265
266 if (p_save != q_save) {
267 switch (inb_p(mda_status_port) & 0x70) {
268 case 0x10:
269 mda_type = TYPE_HERCPLUS;
270 mda_type_name = "HerculesPlus";
271 break;
272 case 0x50:
273 mda_type = TYPE_HERCCOLOR;
274 mda_type_name = "HerculesColor";
275 break;
276 default:
277 mda_type = TYPE_HERC;
278 mda_type_name = "Hercules";
279 break;
280 }
281 }
282
283 return 1;
284}
285
286static void mda_initialize(void)
287{
288 write_mda_b(97, 0x00);
289 write_mda_b(80, 0x01);
290 write_mda_b(82, 0x02);
291 write_mda_b(15, 0x03);
292
293 write_mda_b(25, 0x04);
294 write_mda_b(6, 0x05);
295 write_mda_b(25, 0x06);
296 write_mda_b(25, 0x07);
297
298 write_mda_b(2, 0x08);
299 write_mda_b(13, 0x09);
300 write_mda_b(12, 0x0a);
301 write_mda_b(13, 0x0b);
302
303 write_mda_w(0x0000, 0x0c);
304 write_mda_w(0x0000, 0x0e);
305
306 outb_p(MDA_MODE_VIDEO_EN | MDA_MODE_BLINK_EN, mda_mode_port);
307 outb_p(0x00, mda_status_port);
308 outb_p(0x00, mda_gfx_port);
309}
310
311static const char *mdacon_startup(void)
312{
313 mda_num_columns = 80;
314 mda_num_lines = 25;
315
316 mda_vram_len = 0x01000;
317 mda_vram_base = VGA_MAP_MEM(0xb0000, mda_vram_len);
318
319 mda_index_port = 0x3b4;
320 mda_value_port = 0x3b5;
321 mda_mode_port = 0x3b8;
322 mda_status_port = 0x3ba;
323 mda_gfx_port = 0x3bf;
324
325 mda_type = TYPE_MDA;
326 mda_type_name = "MDA";
327
328 if (! mda_detect()) {
329 printk("mdacon: MDA card not detected.\n");
330 return NULL;
331 }
332
333 if (mda_type != TYPE_MDA) {
334 mda_initialize();
335 }
336
337
338 mda_set_cursor(mda_vram_len - 1);
339
340 printk("mdacon: %s with %ldK of memory detected.\n",
341 mda_type_name, mda_vram_len/1024);
342
343 return "MDA-2";
344}
345
346static void mdacon_init(struct vc_data *c, int init)
347{
348 c->vc_complement_mask = 0x0800;
349 c->vc_display_fg = &mda_display_fg;
350
351 if (init) {
352 c->vc_cols = mda_num_columns;
353 c->vc_rows = mda_num_lines;
354 } else
355 vc_resize(c, mda_num_columns, mda_num_lines);
356
357
358
359 if (mda_display_fg == NULL)
360 mda_display_fg = c;
361}
362
363static void mdacon_deinit(struct vc_data *c)
364{
365
366
367 if (mda_display_fg == c)
368 mda_display_fg = NULL;
369}
370
371static inline u16 mda_convert_attr(u16 ch)
372{
373 u16 attr = 0x0700;
374
375
376
377
378
379
380 if (ch & 0x0800) attr = 0x7000;
381 else if (ch & 0x0400) attr = 0x0100;
382
383 return ((ch & 0x0200) << 2) |
384 (ch & 0x8000) |
385 (ch & 0x00ff) | attr;
386}
387
388static u8 mdacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
389 u8 blink, u8 underline, u8 reverse, u8 italic)
390{
391
392
393
394
395
396
397
398
399 return (intensity & 3) |
400 ((underline & 1) << 2) |
401 ((reverse & 1) << 3) |
402 (!!italic << 4) |
403 ((blink & 1) << 7);
404}
405
406static void mdacon_invert_region(struct vc_data *c, u16 *p, int count)
407{
408 for (; count > 0; count--) {
409 scr_writew(scr_readw(p) ^ 0x0800, p);
410 p++;
411 }
412}
413
414#define MDA_ADDR(x,y) ((u16 *) mda_vram_base + (y)*mda_num_columns + (x))
415
416static void mdacon_putc(struct vc_data *c, int ch, int y, int x)
417{
418 scr_writew(mda_convert_attr(ch), MDA_ADDR(x, y));
419}
420
421static void mdacon_putcs(struct vc_data *c, const unsigned short *s,
422 int count, int y, int x)
423{
424 u16 *dest = MDA_ADDR(x, y);
425
426 for (; count > 0; count--) {
427 scr_writew(mda_convert_attr(scr_readw(s++)), dest++);
428 }
429}
430
431static void mdacon_clear(struct vc_data *c, int y, int x,
432 int height, int width)
433{
434 u16 *dest = MDA_ADDR(x, y);
435 u16 eattr = mda_convert_attr(c->vc_video_erase_char);
436
437 if (width <= 0 || height <= 0)
438 return;
439
440 if (x==0 && width==mda_num_columns) {
441 scr_memsetw(dest, eattr, height*width*2);
442 } else {
443 for (; height > 0; height--, dest+=mda_num_columns)
444 scr_memsetw(dest, eattr, width*2);
445 }
446}
447
448static void mdacon_bmove(struct vc_data *c, int sy, int sx,
449 int dy, int dx, int height, int width)
450{
451 u16 *src, *dest;
452
453 if (width <= 0 || height <= 0)
454 return;
455
456 if (sx==0 && dx==0 && width==mda_num_columns) {
457 scr_memmovew(MDA_ADDR(0,dy), MDA_ADDR(0,sy), height*width*2);
458
459 } else if (dy < sy || (dy == sy && dx < sx)) {
460 src = MDA_ADDR(sx, sy);
461 dest = MDA_ADDR(dx, dy);
462
463 for (; height > 0; height--) {
464 scr_memmovew(dest, src, width*2);
465 src += mda_num_columns;
466 dest += mda_num_columns;
467 }
468 } else {
469 src = MDA_ADDR(sx, sy+height-1);
470 dest = MDA_ADDR(dx, dy+height-1);
471
472 for (; height > 0; height--) {
473 scr_memmovew(dest, src, width*2);
474 src -= mda_num_columns;
475 dest -= mda_num_columns;
476 }
477 }
478}
479
480static int mdacon_switch(struct vc_data *c)
481{
482 return 1;
483}
484
485static int mdacon_set_palette(struct vc_data *c, unsigned char *table)
486{
487 return -EINVAL;
488}
489
490static int mdacon_blank(struct vc_data *c, int blank, int mode_switch)
491{
492 if (mda_type == TYPE_MDA) {
493 if (blank)
494 scr_memsetw((void *)mda_vram_base,
495 mda_convert_attr(c->vc_video_erase_char),
496 c->vc_screenbuf_size);
497
498 return 1;
499 } else {
500 if (blank)
501 outb_p(0x00, mda_mode_port);
502 else
503 outb_p(MDA_MODE_VIDEO_EN | MDA_MODE_BLINK_EN,
504 mda_mode_port);
505 return 0;
506 }
507}
508
509static int mdacon_scrolldelta(struct vc_data *c, int lines)
510{
511 return 0;
512}
513
514static void mdacon_cursor(struct vc_data *c, int mode)
515{
516 if (mode == CM_ERASE) {
517 mda_set_cursor(mda_vram_len - 1);
518 return;
519 }
520
521 mda_set_cursor(c->vc_y*mda_num_columns*2 + c->vc_x*2);
522
523 switch (c->vc_cursor_type & 0x0f) {
524
525 case CUR_LOWER_THIRD: mda_set_cursor_size(10, 13); break;
526 case CUR_LOWER_HALF: mda_set_cursor_size(7, 13); break;
527 case CUR_TWO_THIRDS: mda_set_cursor_size(4, 13); break;
528 case CUR_BLOCK: mda_set_cursor_size(1, 13); break;
529 case CUR_NONE: mda_set_cursor_size(14, 13); break;
530 default: mda_set_cursor_size(12, 13); break;
531 }
532}
533
534static int mdacon_scroll(struct vc_data *c, int t, int b, int dir, int lines)
535{
536 u16 eattr = mda_convert_attr(c->vc_video_erase_char);
537
538 if (!lines)
539 return 0;
540
541 if (lines > c->vc_rows)
542 lines = c->vc_rows;
543
544 switch (dir) {
545
546 case SM_UP:
547 scr_memmovew(MDA_ADDR(0,t), MDA_ADDR(0,t+lines),
548 (b-t-lines)*mda_num_columns*2);
549 scr_memsetw(MDA_ADDR(0,b-lines), eattr,
550 lines*mda_num_columns*2);
551 break;
552
553 case SM_DOWN:
554 scr_memmovew(MDA_ADDR(0,t+lines), MDA_ADDR(0,t),
555 (b-t-lines)*mda_num_columns*2);
556 scr_memsetw(MDA_ADDR(0,t), eattr, lines*mda_num_columns*2);
557 break;
558 }
559
560 return 0;
561}
562
563
564
565
566
567
568static const struct consw mda_con = {
569 .owner = THIS_MODULE,
570 .con_startup = mdacon_startup,
571 .con_init = mdacon_init,
572 .con_deinit = mdacon_deinit,
573 .con_clear = mdacon_clear,
574 .con_putc = mdacon_putc,
575 .con_putcs = mdacon_putcs,
576 .con_cursor = mdacon_cursor,
577 .con_scroll = mdacon_scroll,
578 .con_bmove = mdacon_bmove,
579 .con_switch = mdacon_switch,
580 .con_blank = mdacon_blank,
581 .con_set_palette = mdacon_set_palette,
582 .con_scrolldelta = mdacon_scrolldelta,
583 .con_build_attr = mdacon_build_attr,
584 .con_invert_region = mdacon_invert_region,
585};
586
587int __init mda_console_init(void)
588{
589 if (mda_first_vc > mda_last_vc)
590 return 1;
591
592 return take_over_console(&mda_con, mda_first_vc-1, mda_last_vc-1, 0);
593}
594
595static void __exit mda_console_exit(void)
596{
597 give_up_console(&mda_con);
598}
599
600module_init(mda_console_init);
601module_exit(mda_console_exit);
602
603MODULE_LICENSE("GPL");
604
605