2 * linux/drivers/video/hgafb.c -- Hercules graphics adaptor frame buffer device
4 * Created 25 Nov 1999 by Ferenc Bakonyi (fero@drama.obuda.kando.hu)
5 * Based on skeletonfb.c by Geert Uytterhoeven and
6 * mdacon.c by Andrew Apted
10 * - Revision 0.1.8 (23 Oct 2002): Ported to new framebuffer api.
12 * - Revision 0.1.7 (23 Jan 2001): fix crash resulting from MDA only cards
13 * being detected as Hercules. (Paul G.)
14 * - Revision 0.1.6 (17 Aug 2000): new style structs
16 * - Revision 0.1.5 (13 Mar 2000): spinlocks instead of saveflags();cli();etc
18 * - Revision 0.1.4 (24 Jan 2000): fixed a bug in hga_card_detect() for
20 * - Revision 0.1.3 (22 Jan 2000): modified for the new fb_info structure
21 * screen is cleared after rmmod
23 * module parameter 'nologo={0|1}'
24 * the most important: boot logo :)
25 * - Revision 0.1.0 (6 Dec 1999): faster scrolling and minor fixes
26 * - First release (25 Nov 1999)
28 * This file is subject to the terms and conditions of the GNU General Public
29 * License. See the file COPYING in the main directory of this archive
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/errno.h>
36 #include <linux/spinlock.h>
37 #include <linux/string.h>
39 #include <linux/delay.h>
41 #include <linux/init.h>
42 #include <linux/ioport.h>
43 #include <linux/platform_device.h>
47 #define DPRINTK(args...)
51 /* Description of the hardware layout */
53 static void __iomem
*hga_vram
; /* Base of video memory */
54 static unsigned long hga_vram_len
; /* Size of video memory */
56 #define HGA_ROWADDR(row) ((row%4)*8192 + (row>>2)*90)
60 static inline u8 __iomem
* rowaddr(struct fb_info
*info
, u_int row
)
62 return info
->screen_base
+ HGA_ROWADDR(row
);
65 static int hga_mode
= -1; /* 0 = txt, 1 = gfx mode */
67 static enum { TYPE_HERC
, TYPE_HERCPLUS
, TYPE_HERCCOLOR
} hga_type
;
68 static char *hga_type_name
;
70 #define HGA_INDEX_PORT 0x3b4 /* Register select port */
71 #define HGA_VALUE_PORT 0x3b5 /* Register value port */
72 #define HGA_MODE_PORT 0x3b8 /* Mode control port */
73 #define HGA_STATUS_PORT 0x3ba /* Status and Config port */
74 #define HGA_GFX_PORT 0x3bf /* Graphics control port */
76 /* HGA register values */
78 #define HGA_CURSOR_BLINKING 0x00
79 #define HGA_CURSOR_OFF 0x20
80 #define HGA_CURSOR_SLOWBLINK 0x60
82 #define HGA_MODE_GRAPHICS 0x02
83 #define HGA_MODE_VIDEO_EN 0x08
84 #define HGA_MODE_BLINK_EN 0x20
85 #define HGA_MODE_GFX_PAGE1 0x80
87 #define HGA_STATUS_HSYNC 0x01
88 #define HGA_STATUS_VSYNC 0x80
89 #define HGA_STATUS_VIDEO 0x08
91 #define HGA_CONFIG_COL132 0x08
92 #define HGA_GFX_MODE_EN 0x01
93 #define HGA_GFX_PAGE_EN 0x02
97 static DEFINE_SPINLOCK(hga_reg_lock
);
99 /* Framebuffer driver structures */
101 static struct fb_var_screeninfo hga_default_var __devinitdata
= {
115 static struct fb_fix_screeninfo hga_fix __devinitdata
= {
117 .type
= FB_TYPE_PACKED_PIXELS
, /* (not sure) */
118 .visual
= FB_VISUAL_MONO10
,
122 .accel
= FB_ACCEL_NONE
125 /* Don't assume that tty1 will be the initial current console. */
126 static int release_io_port
= 0;
127 static int release_io_ports
= 0;
128 static int nologo
= 0;
130 /* -------------------------------------------------------------------------
132 * Low level hardware functions
134 * ------------------------------------------------------------------------- */
136 static void write_hga_b(unsigned int val
, unsigned char reg
)
138 outb_p(reg
, HGA_INDEX_PORT
);
139 outb_p(val
, HGA_VALUE_PORT
);
142 static void write_hga_w(unsigned int val
, unsigned char reg
)
144 outb_p(reg
, HGA_INDEX_PORT
); outb_p(val
>> 8, HGA_VALUE_PORT
);
145 outb_p(reg
+1, HGA_INDEX_PORT
); outb_p(val
& 0xff, HGA_VALUE_PORT
);
148 static int test_hga_b(unsigned char val
, unsigned char reg
)
150 outb_p(reg
, HGA_INDEX_PORT
);
151 outb (val
, HGA_VALUE_PORT
);
152 udelay(20); val
= (inb_p(HGA_VALUE_PORT
) == val
);
156 static void hga_clear_screen(void)
158 unsigned char fillchar
= 0xbf; /* magic */
161 spin_lock_irqsave(&hga_reg_lock
, flags
);
162 if (hga_mode
== HGA_TXT
)
164 else if (hga_mode
== HGA_GFX
)
166 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
167 if (fillchar
!= 0xbf)
168 memset_io(hga_vram
, fillchar
, hga_vram_len
);
171 static void hga_txt_mode(void)
175 spin_lock_irqsave(&hga_reg_lock
, flags
);
176 outb_p(HGA_MODE_VIDEO_EN
| HGA_MODE_BLINK_EN
, HGA_MODE_PORT
);
177 outb_p(0x00, HGA_GFX_PORT
);
178 outb_p(0x00, HGA_STATUS_PORT
);
180 write_hga_b(0x61, 0x00); /* horizontal total */
181 write_hga_b(0x50, 0x01); /* horizontal displayed */
182 write_hga_b(0x52, 0x02); /* horizontal sync pos */
183 write_hga_b(0x0f, 0x03); /* horizontal sync width */
185 write_hga_b(0x19, 0x04); /* vertical total */
186 write_hga_b(0x06, 0x05); /* vertical total adjust */
187 write_hga_b(0x19, 0x06); /* vertical displayed */
188 write_hga_b(0x19, 0x07); /* vertical sync pos */
190 write_hga_b(0x02, 0x08); /* interlace mode */
191 write_hga_b(0x0d, 0x09); /* maximum scanline */
192 write_hga_b(0x0c, 0x0a); /* cursor start */
193 write_hga_b(0x0d, 0x0b); /* cursor end */
195 write_hga_w(0x0000, 0x0c); /* start address */
196 write_hga_w(0x0000, 0x0e); /* cursor location */
199 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
202 static void hga_gfx_mode(void)
206 spin_lock_irqsave(&hga_reg_lock
, flags
);
207 outb_p(0x00, HGA_STATUS_PORT
);
208 outb_p(HGA_GFX_MODE_EN
, HGA_GFX_PORT
);
209 outb_p(HGA_MODE_VIDEO_EN
| HGA_MODE_GRAPHICS
, HGA_MODE_PORT
);
211 write_hga_b(0x35, 0x00); /* horizontal total */
212 write_hga_b(0x2d, 0x01); /* horizontal displayed */
213 write_hga_b(0x2e, 0x02); /* horizontal sync pos */
214 write_hga_b(0x07, 0x03); /* horizontal sync width */
216 write_hga_b(0x5b, 0x04); /* vertical total */
217 write_hga_b(0x02, 0x05); /* vertical total adjust */
218 write_hga_b(0x57, 0x06); /* vertical displayed */
219 write_hga_b(0x57, 0x07); /* vertical sync pos */
221 write_hga_b(0x02, 0x08); /* interlace mode */
222 write_hga_b(0x03, 0x09); /* maximum scanline */
223 write_hga_b(0x00, 0x0a); /* cursor start */
224 write_hga_b(0x00, 0x0b); /* cursor end */
226 write_hga_w(0x0000, 0x0c); /* start address */
227 write_hga_w(0x0000, 0x0e); /* cursor location */
230 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
233 static void hga_show_logo(struct fb_info
*info
)
236 void __iomem *dest = hga_vram;
237 char *logo = linux_logo_bw;
240 for (y = 134; y < 134 + 80 ; y++) * this needs some cleanup *
241 for (x = 0; x < 10 ; x++)
242 writeb(~*(logo++),(dest + HGA_ROWADDR(y) + x + 40));
246 static void hga_pan(unsigned int xoffset
, unsigned int yoffset
)
251 base
= (yoffset
/ 8) * 90 + xoffset
;
252 spin_lock_irqsave(&hga_reg_lock
, flags
);
253 write_hga_w(base
, 0x0c); /* start address */
254 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
255 DPRINTK("hga_pan: base:%d\n", base
);
258 static void hga_blank(int blank_mode
)
262 spin_lock_irqsave(&hga_reg_lock
, flags
);
264 outb_p(0x00, HGA_MODE_PORT
); /* disable video */
266 outb_p(HGA_MODE_VIDEO_EN
| HGA_MODE_GRAPHICS
, HGA_MODE_PORT
);
268 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
271 static int __devinit
hga_card_detect(void)
275 unsigned short p_save
, q_save
;
277 hga_vram_len
= 0x08000;
279 hga_vram
= ioremap(0xb0000, hga_vram_len
);
281 if (request_region(0x3b0, 12, "hgafb"))
282 release_io_ports
= 1;
283 if (request_region(0x3bf, 1, "hgafb"))
286 /* do a memory check */
289 q
= hga_vram
+ 0x01000;
291 p_save
= readw(p
); q_save
= readw(q
);
293 writew(0xaa55, p
); if (readw(p
) == 0xaa55) count
++;
294 writew(0x55aa, p
); if (readw(p
) == 0x55aa) count
++;
300 /* Ok, there is definitely a card registering at the correct
301 * memory location, so now we do an I/O port test.
304 if (!test_hga_b(0x66, 0x0f)) /* cursor low register */
307 if (!test_hga_b(0x99, 0x0f)) /* cursor low register */
310 /* See if the card is a Hercules, by checking whether the vsync
311 * bit of the status register is changing. This test lasts for
312 * approximately 1/10th of a second.
315 p_save
= q_save
= inb_p(HGA_STATUS_PORT
) & HGA_STATUS_VSYNC
;
317 for (count
=0; count
< 50000 && p_save
== q_save
; count
++) {
318 q_save
= inb(HGA_STATUS_PORT
) & HGA_STATUS_VSYNC
;
322 if (p_save
== q_save
)
325 switch (inb_p(HGA_STATUS_PORT
) & 0x70) {
327 hga_type
= TYPE_HERCPLUS
;
328 hga_type_name
= "HerculesPlus";
331 hga_type
= TYPE_HERCCOLOR
;
332 hga_type_name
= "HerculesColor";
335 hga_type
= TYPE_HERC
;
336 hga_type_name
= "Hercules";
341 if (release_io_ports
)
342 release_region(0x3b0, 12);
344 release_region(0x3bf, 1);
349 * hgafb_open - open the framebuffer device
350 * @info:pointer to fb_info object containing info for current hga board
351 * @int:open by console system or userland.
354 static int hgafb_open(struct fb_info
*info
, int init
)
358 if (!nologo
) hga_show_logo(info
);
363 * hgafb_open - open the framebuffer device
364 * @info:pointer to fb_info object containing info for current hga board
365 * @int:open by console system or userland.
368 static int hgafb_release(struct fb_info
*info
, int init
)
376 * hgafb_setcolreg - set color registers
377 * @regno:register index to set
378 * @red:red value, unused
379 * @green:green value, unused
380 * @blue:blue value, unused
381 * @transp:transparency value, unused
384 * This callback function is used to set the color registers of a HGA
385 * board. Since we have only two fixed colors only @regno is checked.
386 * A zero is returned on success and 1 for failure.
389 static int hgafb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
390 u_int transp
, struct fb_info
*info
)
398 * hga_pan_display - pan or wrap the display
399 * @var:contains new xoffset, yoffset and vmode values
400 * @info:pointer to fb_info object containing info for current hga board
402 * This function looks only at xoffset, yoffset and the %FB_VMODE_YWRAP
403 * flag in @var. If input parameters are correct it calls hga_pan() to
404 * program the hardware. @info->var is updated to the new values.
405 * A zero is returned on success and %-EINVAL for failure.
408 static int hgafb_pan_display(struct fb_var_screeninfo
*var
,
409 struct fb_info
*info
)
411 if (var
->vmode
& FB_VMODE_YWRAP
) {
412 if (var
->yoffset
< 0 ||
413 var
->yoffset
>= info
->var
.yres_virtual
||
417 if (var
->xoffset
+ var
->xres
> info
->var
.xres_virtual
418 || var
->yoffset
+ var
->yres
> info
->var
.yres_virtual
423 hga_pan(var
->xoffset
, var
->yoffset
);
428 * hgafb_blank - (un)blank the screen
429 * @blank_mode:blanking method to use
432 * Blank the screen if blank_mode != 0, else unblank.
433 * Implements VESA suspend and powerdown modes on hardware that supports
434 * disabling hsync/vsync:
435 * @blank_mode == 2 means suspend vsync,
436 * @blank_mode == 3 means suspend hsync,
437 * @blank_mode == 4 means powerdown.
440 static int hgafb_blank(int blank_mode
, struct fb_info
*info
)
442 hga_blank(blank_mode
);
449 #ifdef CONFIG_FB_HGA_ACCEL
450 static void hgafb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
457 for (rows
= rect
->height
; rows
--; y
++) {
458 dest
= rowaddr(info
, y
) + (rect
->dx
>> 3);
461 //fb_memset(dest, rect->color, (rect->width >> 3));
464 fb_writeb(~(fb_readb(dest
)), dest
);
470 static void hgafb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*area
)
476 if (area
->dy
<= area
->sy
) {
480 for (rows
= area
->height
; rows
--; ) {
481 src
= rowaddr(info
, y1
) + (area
->sx
>> 3);
482 dest
= rowaddr(info
, y2
) + (area
->dx
>> 3);
483 //fb_memmove(dest, src, (area->width >> 3));
488 y1
= area
->sy
+ area
->height
- 1;
489 y2
= area
->dy
+ area
->height
- 1;
491 for (rows
= area
->height
; rows
--;) {
492 src
= rowaddr(info
, y1
) + (area
->sx
>> 3);
493 dest
= rowaddr(info
, y2
) + (area
->dx
>> 3);
494 //fb_memmove(dest, src, (area->width >> 3));
501 static void hgafb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
504 u8
*cdat
= (u8
*) image
->data
;
505 u_int rows
, y
= image
->dy
;
508 for (rows
= image
->height
; rows
--; y
++) {
510 dest
= rowaddr(info
, y
) + (image
->dx
>> 3);
514 #else /* !CONFIG_FB_HGA_ACCEL */
515 #define hgafb_fillrect cfb_fillrect
516 #define hgafb_copyarea cfb_copyarea
517 #define hgafb_imageblit cfb_imageblit
518 #endif /* CONFIG_FB_HGA_ACCEL */
521 static struct fb_ops hgafb_ops
= {
522 .owner
= THIS_MODULE
,
523 .fb_open
= hgafb_open
,
524 .fb_release
= hgafb_release
,
525 .fb_setcolreg
= hgafb_setcolreg
,
526 .fb_pan_display
= hgafb_pan_display
,
527 .fb_blank
= hgafb_blank
,
528 .fb_fillrect
= hgafb_fillrect
,
529 .fb_copyarea
= hgafb_copyarea
,
530 .fb_imageblit
= hgafb_imageblit
,
533 /* ------------------------------------------------------------------------- *
535 * Functions in fb_info
537 * ------------------------------------------------------------------------- */
539 /* ------------------------------------------------------------------------- */
545 static int __devinit
hgafb_probe(struct platform_device
*pdev
)
547 struct fb_info
*info
;
549 if (! hga_card_detect()) {
550 printk(KERN_INFO
"hgafb: HGA card not detected.\n");
556 printk(KERN_INFO
"hgafb: %s with %ldK of memory detected.\n",
557 hga_type_name
, hga_vram_len
/1024);
559 info
= framebuffer_alloc(0, &pdev
->dev
);
565 hga_fix
.smem_start
= (unsigned long)hga_vram
;
566 hga_fix
.smem_len
= hga_vram_len
;
568 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
569 info
->var
= hga_default_var
;
571 info
->monspecs
.hfmin
= 0;
572 info
->monspecs
.hfmax
= 0;
573 info
->monspecs
.vfmin
= 10000;
574 info
->monspecs
.vfmax
= 10000;
575 info
->monspecs
.dpms
= 0;
576 info
->fbops
= &hgafb_ops
;
577 info
->screen_base
= hga_vram
;
579 if (register_framebuffer(info
) < 0) {
580 framebuffer_release(info
);
585 printk(KERN_INFO
"fb%d: %s frame buffer device\n",
586 info
->node
, info
->fix
.id
);
587 platform_set_drvdata(pdev
, info
);
591 static int __devexit
hgafb_remove(struct platform_device
*pdev
)
593 struct fb_info
*info
= platform_get_drvdata(pdev
);
599 unregister_framebuffer(info
);
600 framebuffer_release(info
);
605 if (release_io_ports
)
606 release_region(0x3b0, 12);
609 release_region(0x3bf, 1);
614 static struct platform_driver hgafb_driver
= {
615 .probe
= hgafb_probe
,
616 .remove
= __devexit_p(hgafb_remove
),
622 static struct platform_device
*hgafb_device
;
624 static int __init
hgafb_init(void)
628 if (fb_get_options("hgafb", NULL
))
631 ret
= platform_driver_register(&hgafb_driver
);
634 hgafb_device
= platform_device_register_simple("hgafb", 0, NULL
, 0);
636 if (IS_ERR(hgafb_device
)) {
637 platform_driver_unregister(&hgafb_driver
);
638 ret
= PTR_ERR(hgafb_device
);
645 static void __exit
hgafb_exit(void)
647 platform_device_unregister(hgafb_device
);
648 platform_driver_unregister(&hgafb_driver
);
651 /* -------------------------------------------------------------------------
655 * ------------------------------------------------------------------------- */
657 MODULE_AUTHOR("Ferenc Bakonyi (fero@drama.obuda.kando.hu)");
658 MODULE_DESCRIPTION("FBDev driver for Hercules Graphics Adaptor");
659 MODULE_LICENSE("GPL");
661 module_param(nologo
, bool, 0);
662 MODULE_PARM_DESC(nologo
, "Disables startup logo if != 0 (default=0)");
663 module_init(hgafb_init
);
664 module_exit(hgafb_exit
);