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/slab.h>
40 #include <linux/delay.h>
42 #include <linux/init.h>
43 #include <linux/ioport.h>
44 #include <linux/platform_device.h>
49 #define DPRINTK(args...) printk(KERN_DEBUG __FILE__": " ##args)
51 #define DPRINTK(args...)
55 #define CHKINFO(ret) if (info != &fb_info) { printk(KERN_DEBUG __FILE__": This should never happen, line:%d \n", __LINE__); return ret; }
60 /* Description of the hardware layout */
62 static void __iomem
*hga_vram
; /* Base of video memory */
63 static unsigned long hga_vram_len
; /* Size of video memory */
65 #define HGA_ROWADDR(row) ((row%4)*8192 + (row>>2)*90)
69 static inline u8 __iomem
* rowaddr(struct fb_info
*info
, u_int row
)
71 return info
->screen_base
+ HGA_ROWADDR(row
);
74 static int hga_mode
= -1; /* 0 = txt, 1 = gfx mode */
76 static enum { TYPE_HERC
, TYPE_HERCPLUS
, TYPE_HERCCOLOR
} hga_type
;
77 static char *hga_type_name
;
79 #define HGA_INDEX_PORT 0x3b4 /* Register select port */
80 #define HGA_VALUE_PORT 0x3b5 /* Register value port */
81 #define HGA_MODE_PORT 0x3b8 /* Mode control port */
82 #define HGA_STATUS_PORT 0x3ba /* Status and Config port */
83 #define HGA_GFX_PORT 0x3bf /* Graphics control port */
85 /* HGA register values */
87 #define HGA_CURSOR_BLINKING 0x00
88 #define HGA_CURSOR_OFF 0x20
89 #define HGA_CURSOR_SLOWBLINK 0x60
91 #define HGA_MODE_GRAPHICS 0x02
92 #define HGA_MODE_VIDEO_EN 0x08
93 #define HGA_MODE_BLINK_EN 0x20
94 #define HGA_MODE_GFX_PAGE1 0x80
96 #define HGA_STATUS_HSYNC 0x01
97 #define HGA_STATUS_VSYNC 0x80
98 #define HGA_STATUS_VIDEO 0x08
100 #define HGA_CONFIG_COL132 0x08
101 #define HGA_GFX_MODE_EN 0x01
102 #define HGA_GFX_PAGE_EN 0x02
106 static DEFINE_SPINLOCK(hga_reg_lock
);
108 /* Framebuffer driver structures */
110 static struct fb_var_screeninfo __initdata hga_default_var
= {
124 static struct fb_fix_screeninfo __initdata hga_fix
= {
126 .type
= FB_TYPE_PACKED_PIXELS
, /* (not sure) */
127 .visual
= FB_VISUAL_MONO10
,
131 .accel
= FB_ACCEL_NONE
134 /* Don't assume that tty1 will be the initial current console. */
135 static int release_io_port
= 0;
136 static int release_io_ports
= 0;
137 static int nologo
= 0;
139 /* -------------------------------------------------------------------------
141 * Low level hardware functions
143 * ------------------------------------------------------------------------- */
145 static void write_hga_b(unsigned int val
, unsigned char reg
)
147 outb_p(reg
, HGA_INDEX_PORT
);
148 outb_p(val
, HGA_VALUE_PORT
);
151 static void write_hga_w(unsigned int val
, unsigned char reg
)
153 outb_p(reg
, HGA_INDEX_PORT
); outb_p(val
>> 8, HGA_VALUE_PORT
);
154 outb_p(reg
+1, HGA_INDEX_PORT
); outb_p(val
& 0xff, HGA_VALUE_PORT
);
157 static int test_hga_b(unsigned char val
, unsigned char reg
)
159 outb_p(reg
, HGA_INDEX_PORT
);
160 outb (val
, HGA_VALUE_PORT
);
161 udelay(20); val
= (inb_p(HGA_VALUE_PORT
) == val
);
165 static void hga_clear_screen(void)
167 unsigned char fillchar
= 0xbf; /* magic */
170 spin_lock_irqsave(&hga_reg_lock
, flags
);
171 if (hga_mode
== HGA_TXT
)
173 else if (hga_mode
== HGA_GFX
)
175 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
176 if (fillchar
!= 0xbf)
177 memset_io(hga_vram
, fillchar
, hga_vram_len
);
180 static void hga_txt_mode(void)
184 spin_lock_irqsave(&hga_reg_lock
, flags
);
185 outb_p(HGA_MODE_VIDEO_EN
| HGA_MODE_BLINK_EN
, HGA_MODE_PORT
);
186 outb_p(0x00, HGA_GFX_PORT
);
187 outb_p(0x00, HGA_STATUS_PORT
);
189 write_hga_b(0x61, 0x00); /* horizontal total */
190 write_hga_b(0x50, 0x01); /* horizontal displayed */
191 write_hga_b(0x52, 0x02); /* horizontal sync pos */
192 write_hga_b(0x0f, 0x03); /* horizontal sync width */
194 write_hga_b(0x19, 0x04); /* vertical total */
195 write_hga_b(0x06, 0x05); /* vertical total adjust */
196 write_hga_b(0x19, 0x06); /* vertical displayed */
197 write_hga_b(0x19, 0x07); /* vertical sync pos */
199 write_hga_b(0x02, 0x08); /* interlace mode */
200 write_hga_b(0x0d, 0x09); /* maximum scanline */
201 write_hga_b(0x0c, 0x0a); /* cursor start */
202 write_hga_b(0x0d, 0x0b); /* cursor end */
204 write_hga_w(0x0000, 0x0c); /* start address */
205 write_hga_w(0x0000, 0x0e); /* cursor location */
208 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
211 static void hga_gfx_mode(void)
215 spin_lock_irqsave(&hga_reg_lock
, flags
);
216 outb_p(0x00, HGA_STATUS_PORT
);
217 outb_p(HGA_GFX_MODE_EN
, HGA_GFX_PORT
);
218 outb_p(HGA_MODE_VIDEO_EN
| HGA_MODE_GRAPHICS
, HGA_MODE_PORT
);
220 write_hga_b(0x35, 0x00); /* horizontal total */
221 write_hga_b(0x2d, 0x01); /* horizontal displayed */
222 write_hga_b(0x2e, 0x02); /* horizontal sync pos */
223 write_hga_b(0x07, 0x03); /* horizontal sync width */
225 write_hga_b(0x5b, 0x04); /* vertical total */
226 write_hga_b(0x02, 0x05); /* vertical total adjust */
227 write_hga_b(0x57, 0x06); /* vertical displayed */
228 write_hga_b(0x57, 0x07); /* vertical sync pos */
230 write_hga_b(0x02, 0x08); /* interlace mode */
231 write_hga_b(0x03, 0x09); /* maximum scanline */
232 write_hga_b(0x00, 0x0a); /* cursor start */
233 write_hga_b(0x00, 0x0b); /* cursor end */
235 write_hga_w(0x0000, 0x0c); /* start address */
236 write_hga_w(0x0000, 0x0e); /* cursor location */
239 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
242 static void hga_show_logo(struct fb_info
*info
)
245 void __iomem *dest = hga_vram;
246 char *logo = linux_logo_bw;
249 for (y = 134; y < 134 + 80 ; y++) * this needs some cleanup *
250 for (x = 0; x < 10 ; x++)
251 writeb(~*(logo++),(dest + HGA_ROWADDR(y) + x + 40));
255 static void hga_pan(unsigned int xoffset
, unsigned int yoffset
)
260 base
= (yoffset
/ 8) * 90 + xoffset
;
261 spin_lock_irqsave(&hga_reg_lock
, flags
);
262 write_hga_w(base
, 0x0c); /* start address */
263 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
264 DPRINTK("hga_pan: base:%d\n", base
);
267 static void hga_blank(int blank_mode
)
271 spin_lock_irqsave(&hga_reg_lock
, flags
);
273 outb_p(0x00, HGA_MODE_PORT
); /* disable video */
275 outb_p(HGA_MODE_VIDEO_EN
| HGA_MODE_GRAPHICS
, HGA_MODE_PORT
);
277 spin_unlock_irqrestore(&hga_reg_lock
, flags
);
280 static int __init
hga_card_detect(void)
284 unsigned short p_save
, q_save
;
286 hga_vram_len
= 0x08000;
288 hga_vram
= ioremap(0xb0000, hga_vram_len
);
290 if (request_region(0x3b0, 12, "hgafb"))
291 release_io_ports
= 1;
292 if (request_region(0x3bf, 1, "hgafb"))
295 /* do a memory check */
298 q
= hga_vram
+ 0x01000;
300 p_save
= readw(p
); q_save
= readw(q
);
302 writew(0xaa55, p
); if (readw(p
) == 0xaa55) count
++;
303 writew(0x55aa, p
); if (readw(p
) == 0x55aa) count
++;
309 /* Ok, there is definitely a card registering at the correct
310 * memory location, so now we do an I/O port test.
313 if (!test_hga_b(0x66, 0x0f)) /* cursor low register */
316 if (!test_hga_b(0x99, 0x0f)) /* cursor low register */
319 /* See if the card is a Hercules, by checking whether the vsync
320 * bit of the status register is changing. This test lasts for
321 * approximately 1/10th of a second.
324 p_save
= q_save
= inb_p(HGA_STATUS_PORT
) & HGA_STATUS_VSYNC
;
326 for (count
=0; count
< 50000 && p_save
== q_save
; count
++) {
327 q_save
= inb(HGA_STATUS_PORT
) & HGA_STATUS_VSYNC
;
331 if (p_save
== q_save
)
334 switch (inb_p(HGA_STATUS_PORT
) & 0x70) {
336 hga_type
= TYPE_HERCPLUS
;
337 hga_type_name
= "HerculesPlus";
340 hga_type
= TYPE_HERCCOLOR
;
341 hga_type_name
= "HerculesColor";
344 hga_type
= TYPE_HERC
;
345 hga_type_name
= "Hercules";
350 if (release_io_ports
)
351 release_region(0x3b0, 12);
353 release_region(0x3bf, 1);
358 * hgafb_open - open the framebuffer device
359 * @info:pointer to fb_info object containing info for current hga board
360 * @int:open by console system or userland.
363 static int hgafb_open(struct fb_info
*info
, int init
)
367 if (!nologo
) hga_show_logo(info
);
372 * hgafb_open - open the framebuffer device
373 * @info:pointer to fb_info object containing info for current hga board
374 * @int:open by console system or userland.
377 static int hgafb_release(struct fb_info
*info
, int init
)
385 * hgafb_setcolreg - set color registers
386 * @regno:register index to set
387 * @red:red value, unused
388 * @green:green value, unused
389 * @blue:blue value, unused
390 * @transp:transparency value, unused
393 * This callback function is used to set the color registers of a HGA
394 * board. Since we have only two fixed colors only @regno is checked.
395 * A zero is returned on success and 1 for failure.
398 static int hgafb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
399 u_int transp
, struct fb_info
*info
)
407 * hga_pan_display - pan or wrap the display
408 * @var:contains new xoffset, yoffset and vmode values
409 * @info:pointer to fb_info object containing info for current hga board
411 * This function looks only at xoffset, yoffset and the %FB_VMODE_YWRAP
412 * flag in @var. If input parameters are correct it calls hga_pan() to
413 * program the hardware. @info->var is updated to the new values.
414 * A zero is returned on success and %-EINVAL for failure.
417 static int hgafb_pan_display(struct fb_var_screeninfo
*var
,
418 struct fb_info
*info
)
420 if (var
->vmode
& FB_VMODE_YWRAP
) {
421 if (var
->yoffset
< 0 ||
422 var
->yoffset
>= info
->var
.yres_virtual
||
426 if (var
->xoffset
+ var
->xres
> info
->var
.xres_virtual
427 || var
->yoffset
+ var
->yres
> info
->var
.yres_virtual
432 hga_pan(var
->xoffset
, var
->yoffset
);
437 * hgafb_blank - (un)blank the screen
438 * @blank_mode:blanking method to use
441 * Blank the screen if blank_mode != 0, else unblank.
442 * Implements VESA suspend and powerdown modes on hardware that supports
443 * disabling hsync/vsync:
444 * @blank_mode == 2 means suspend vsync,
445 * @blank_mode == 3 means suspend hsync,
446 * @blank_mode == 4 means powerdown.
449 static int hgafb_blank(int blank_mode
, struct fb_info
*info
)
451 hga_blank(blank_mode
);
458 #ifdef CONFIG_FB_HGA_ACCEL
459 static void hgafb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
466 for (rows
= rect
->height
; rows
--; y
++) {
467 dest
= rowaddr(info
, y
) + (rect
->dx
>> 3);
470 //fb_memset(dest, rect->color, (rect->width >> 3));
473 fb_writeb(~(fb_readb(dest
)), dest
);
479 static void hgafb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*area
)
485 if (area
->dy
<= area
->sy
) {
489 for (rows
= area
->height
; rows
--; ) {
490 src
= rowaddr(info
, y1
) + (area
->sx
>> 3);
491 dest
= rowaddr(info
, y2
) + (area
->dx
>> 3);
492 //fb_memmove(dest, src, (area->width >> 3));
497 y1
= area
->sy
+ area
->height
- 1;
498 y2
= area
->dy
+ area
->height
- 1;
500 for (rows
= area
->height
; rows
--;) {
501 src
= rowaddr(info
, y1
) + (area
->sx
>> 3);
502 dest
= rowaddr(info
, y2
) + (area
->dx
>> 3);
503 //fb_memmove(dest, src, (area->width >> 3));
510 static void hgafb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
513 u8
*cdat
= (u8
*) image
->data
;
514 u_int rows
, y
= image
->dy
;
517 for (rows
= image
->height
; rows
--; y
++) {
519 dest
= rowaddr(info
, y
) + (image
->dx
>> 3);
523 #else /* !CONFIG_FB_HGA_ACCEL */
524 #define hgafb_fillrect cfb_fillrect
525 #define hgafb_copyarea cfb_copyarea
526 #define hgafb_imageblit cfb_imageblit
527 #endif /* CONFIG_FB_HGA_ACCEL */
530 static struct fb_ops hgafb_ops
= {
531 .owner
= THIS_MODULE
,
532 .fb_open
= hgafb_open
,
533 .fb_release
= hgafb_release
,
534 .fb_setcolreg
= hgafb_setcolreg
,
535 .fb_pan_display
= hgafb_pan_display
,
536 .fb_blank
= hgafb_blank
,
537 .fb_fillrect
= hgafb_fillrect
,
538 .fb_copyarea
= hgafb_copyarea
,
539 .fb_imageblit
= hgafb_imageblit
,
542 /* ------------------------------------------------------------------------- *
544 * Functions in fb_info
546 * ------------------------------------------------------------------------- */
548 /* ------------------------------------------------------------------------- */
554 static int __devinit
hgafb_probe(struct platform_device
*pdev
)
556 struct fb_info
*info
;
558 if (! hga_card_detect()) {
559 printk(KERN_INFO
"hgafb: HGA card not detected.\n");
565 printk(KERN_INFO
"hgafb: %s with %ldK of memory detected.\n",
566 hga_type_name
, hga_vram_len
/1024);
568 info
= framebuffer_alloc(0, &pdev
->dev
);
574 hga_fix
.smem_start
= (unsigned long)hga_vram
;
575 hga_fix
.smem_len
= hga_vram_len
;
577 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_YPAN
;
578 info
->var
= hga_default_var
;
580 info
->monspecs
.hfmin
= 0;
581 info
->monspecs
.hfmax
= 0;
582 info
->monspecs
.vfmin
= 10000;
583 info
->monspecs
.vfmax
= 10000;
584 info
->monspecs
.dpms
= 0;
585 info
->fbops
= &hgafb_ops
;
586 info
->screen_base
= hga_vram
;
588 if (register_framebuffer(info
) < 0) {
589 framebuffer_release(info
);
594 printk(KERN_INFO
"fb%d: %s frame buffer device\n",
595 info
->node
, info
->fix
.id
);
596 platform_set_drvdata(pdev
, info
);
600 static int hgafb_remove(struct platform_device
*pdev
)
602 struct fb_info
*info
= platform_get_drvdata(pdev
);
608 unregister_framebuffer(info
);
609 framebuffer_release(info
);
614 if (release_io_ports
)
615 release_region(0x3b0, 12);
618 release_region(0x3bf, 1);
623 static struct platform_driver hgafb_driver
= {
624 .probe
= hgafb_probe
,
625 .remove
= hgafb_remove
,
631 static struct platform_device
*hgafb_device
;
633 static int __init
hgafb_init(void)
637 if (fb_get_options("hgafb", NULL
))
640 ret
= platform_driver_register(&hgafb_driver
);
643 hgafb_device
= platform_device_register_simple("hgafb", 0, NULL
, 0);
645 if (IS_ERR(hgafb_device
)) {
646 platform_driver_unregister(&hgafb_driver
);
647 ret
= PTR_ERR(hgafb_device
);
654 static void __exit
hgafb_exit(void)
656 platform_device_unregister(hgafb_device
);
657 platform_driver_unregister(&hgafb_driver
);
660 /* -------------------------------------------------------------------------
664 * ------------------------------------------------------------------------- */
666 MODULE_AUTHOR("Ferenc Bakonyi (fero@drama.obuda.kando.hu)");
667 MODULE_DESCRIPTION("FBDev driver for Hercules Graphics Adaptor");
668 MODULE_LICENSE("GPL");
670 module_param(nologo
, bool, 0);
671 MODULE_PARM_DESC(nologo
, "Disables startup logo if != 0 (default=0)");
672 module_init(hgafb_init
);
673 module_exit(hgafb_exit
);