xref: /openbmc/linux/drivers/video/fbdev/hgafb.c (revision b3e148d7)
1 /*
2  * linux/drivers/video/hgafb.c -- Hercules graphics adaptor frame buffer device
3  *
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
7  *
8  * History:
9  *
10  * - Revision 0.1.8 (23 Oct 2002): Ported to new framebuffer api.
11  *
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
15  *                                 documentation
16  * - Revision 0.1.5 (13 Mar 2000): spinlocks instead of saveflags();cli();etc
17  *                                 minor fixes
18  * - Revision 0.1.4 (24 Jan 2000): fixed a bug in hga_card_detect() for
19  *                                  HGA-only systems
20  * - Revision 0.1.3 (22 Jan 2000): modified for the new fb_info structure
21  *                                 screen is cleared after rmmod
22  *                                 virtual resolutions
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)
27  *
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
30  * for more details.
31  */
32 
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>
38 #include <linux/mm.h>
39 #include <linux/delay.h>
40 #include <linux/fb.h>
41 #include <linux/init.h>
42 #include <linux/ioport.h>
43 #include <linux/platform_device.h>
44 #include <asm/io.h>
45 #include <asm/vga.h>
46 
47 #if 0
48 #define DPRINTK(args...) printk(KERN_DEBUG __FILE__": " ##args)
49 #else
50 #define DPRINTK(args...)
51 #endif
52 
53 #if 0
54 #define CHKINFO(ret) if (info != &fb_info) { printk(KERN_DEBUG __FILE__": This should never happen, line:%d \n", __LINE__); return ret; }
55 #else
56 #define CHKINFO(ret)
57 #endif
58 
59 /* Description of the hardware layout */
60 
61 static void __iomem *hga_vram;			/* Base of video memory */
62 static unsigned long hga_vram_len;		/* Size of video memory */
63 
64 #define HGA_ROWADDR(row) ((row%4)*8192 + (row>>2)*90)
65 #define HGA_TXT			0
66 #define HGA_GFX			1
67 
rowaddr(struct fb_info * info,u_int row)68 static inline u8 __iomem * rowaddr(struct fb_info *info, u_int row)
69 {
70 	return info->screen_base + HGA_ROWADDR(row);
71 }
72 
73 static int hga_mode = -1;			/* 0 = txt, 1 = gfx mode */
74 
75 static enum { TYPE_HERC, TYPE_HERCPLUS, TYPE_HERCCOLOR } hga_type;
76 static char *hga_type_name;
77 
78 #define HGA_INDEX_PORT		0x3b4		/* Register select port */
79 #define HGA_VALUE_PORT		0x3b5		/* Register value port */
80 #define HGA_MODE_PORT		0x3b8		/* Mode control port */
81 #define HGA_STATUS_PORT		0x3ba		/* Status and Config port */
82 #define HGA_GFX_PORT		0x3bf		/* Graphics control port */
83 
84 /* HGA register values */
85 
86 #define HGA_CURSOR_BLINKING	0x00
87 #define HGA_CURSOR_OFF		0x20
88 #define HGA_CURSOR_SLOWBLINK	0x60
89 
90 #define HGA_MODE_GRAPHICS	0x02
91 #define HGA_MODE_VIDEO_EN	0x08
92 #define HGA_MODE_BLINK_EN	0x20
93 #define HGA_MODE_GFX_PAGE1	0x80
94 
95 #define HGA_STATUS_HSYNC	0x01
96 #define HGA_STATUS_VSYNC	0x80
97 #define HGA_STATUS_VIDEO	0x08
98 
99 #define HGA_CONFIG_COL132	0x08
100 #define HGA_GFX_MODE_EN		0x01
101 #define HGA_GFX_PAGE_EN		0x02
102 
103 /* Global locks */
104 
105 static DEFINE_SPINLOCK(hga_reg_lock);
106 
107 /* Framebuffer driver structures */
108 
109 static const struct fb_var_screeninfo hga_default_var = {
110 	.xres		= 720,
111 	.yres 		= 348,
112 	.xres_virtual 	= 720,
113 	.yres_virtual	= 348,
114 	.bits_per_pixel = 1,
115 	.red 		= {0, 1, 0},
116 	.green 		= {0, 1, 0},
117 	.blue 		= {0, 1, 0},
118 	.transp 	= {0, 0, 0},
119 	.height 	= -1,
120 	.width 		= -1,
121 };
122 
123 static struct fb_fix_screeninfo hga_fix = {
124 	.id 		= "HGA",
125 	.type 		= FB_TYPE_PACKED_PIXELS,	/* (not sure) */
126 	.visual 	= FB_VISUAL_MONO10,
127 	.xpanstep 	= 8,
128 	.ypanstep 	= 8,
129 	.line_length 	= 90,
130 	.accel 		= FB_ACCEL_NONE
131 };
132 
133 /* Don't assume that tty1 will be the initial current console. */
134 static int release_io_port = 0;
135 static int release_io_ports = 0;
136 static bool nologo = 0;
137 
138 /* -------------------------------------------------------------------------
139  *
140  * Low level hardware functions
141  *
142  * ------------------------------------------------------------------------- */
143 
write_hga_b(unsigned int val,unsigned char reg)144 static void write_hga_b(unsigned int val, unsigned char reg)
145 {
146 	outb_p(reg, HGA_INDEX_PORT);
147 	outb_p(val, HGA_VALUE_PORT);
148 }
149 
write_hga_w(unsigned int val,unsigned char reg)150 static void write_hga_w(unsigned int val, unsigned char reg)
151 {
152 	outb_p(reg,   HGA_INDEX_PORT); outb_p(val >> 8,   HGA_VALUE_PORT);
153 	outb_p(reg+1, HGA_INDEX_PORT); outb_p(val & 0xff, HGA_VALUE_PORT);
154 }
155 
test_hga_b(unsigned char val,unsigned char reg)156 static int test_hga_b(unsigned char val, unsigned char reg)
157 {
158 	outb_p(reg, HGA_INDEX_PORT);
159 	outb  (val, HGA_VALUE_PORT);
160 	udelay(20); val = (inb_p(HGA_VALUE_PORT) == val);
161 	return val;
162 }
163 
hga_clear_screen(void)164 static void hga_clear_screen(void)
165 {
166 	unsigned char fillchar = 0xbf; /* magic */
167 	unsigned long flags;
168 
169 	spin_lock_irqsave(&hga_reg_lock, flags);
170 	if (hga_mode == HGA_TXT)
171 		fillchar = ' ';
172 	else if (hga_mode == HGA_GFX)
173 		fillchar = 0x00;
174 	spin_unlock_irqrestore(&hga_reg_lock, flags);
175 	if (fillchar != 0xbf)
176 		memset_io(hga_vram, fillchar, hga_vram_len);
177 }
178 
hga_txt_mode(void)179 static void hga_txt_mode(void)
180 {
181 	unsigned long flags;
182 
183 	spin_lock_irqsave(&hga_reg_lock, flags);
184 	outb_p(HGA_MODE_VIDEO_EN | HGA_MODE_BLINK_EN, HGA_MODE_PORT);
185 	outb_p(0x00, HGA_GFX_PORT);
186 	outb_p(0x00, HGA_STATUS_PORT);
187 
188 	write_hga_b(0x61, 0x00);	/* horizontal total */
189 	write_hga_b(0x50, 0x01);	/* horizontal displayed */
190 	write_hga_b(0x52, 0x02);	/* horizontal sync pos */
191 	write_hga_b(0x0f, 0x03);	/* horizontal sync width */
192 
193 	write_hga_b(0x19, 0x04);	/* vertical total */
194 	write_hga_b(0x06, 0x05);	/* vertical total adjust */
195 	write_hga_b(0x19, 0x06);	/* vertical displayed */
196 	write_hga_b(0x19, 0x07);	/* vertical sync pos */
197 
198 	write_hga_b(0x02, 0x08);	/* interlace mode */
199 	write_hga_b(0x0d, 0x09);	/* maximum scanline */
200 	write_hga_b(0x0c, 0x0a);	/* cursor start */
201 	write_hga_b(0x0d, 0x0b);	/* cursor end */
202 
203 	write_hga_w(0x0000, 0x0c);	/* start address */
204 	write_hga_w(0x0000, 0x0e);	/* cursor location */
205 
206 	hga_mode = HGA_TXT;
207 	spin_unlock_irqrestore(&hga_reg_lock, flags);
208 }
209 
hga_gfx_mode(void)210 static void hga_gfx_mode(void)
211 {
212 	unsigned long flags;
213 
214 	spin_lock_irqsave(&hga_reg_lock, flags);
215 	outb_p(0x00, HGA_STATUS_PORT);
216 	outb_p(HGA_GFX_MODE_EN, HGA_GFX_PORT);
217 	outb_p(HGA_MODE_VIDEO_EN | HGA_MODE_GRAPHICS, HGA_MODE_PORT);
218 
219 	write_hga_b(0x35, 0x00);	/* horizontal total */
220 	write_hga_b(0x2d, 0x01);	/* horizontal displayed */
221 	write_hga_b(0x2e, 0x02);	/* horizontal sync pos */
222 	write_hga_b(0x07, 0x03);	/* horizontal sync width */
223 
224 	write_hga_b(0x5b, 0x04);	/* vertical total */
225 	write_hga_b(0x02, 0x05);	/* vertical total adjust */
226 	write_hga_b(0x57, 0x06);	/* vertical displayed */
227 	write_hga_b(0x57, 0x07);	/* vertical sync pos */
228 
229 	write_hga_b(0x02, 0x08);	/* interlace mode */
230 	write_hga_b(0x03, 0x09);	/* maximum scanline */
231 	write_hga_b(0x00, 0x0a);	/* cursor start */
232 	write_hga_b(0x00, 0x0b);	/* cursor end */
233 
234 	write_hga_w(0x0000, 0x0c);	/* start address */
235 	write_hga_w(0x0000, 0x0e);	/* cursor location */
236 
237 	hga_mode = HGA_GFX;
238 	spin_unlock_irqrestore(&hga_reg_lock, flags);
239 }
240 
hga_show_logo(struct fb_info * info)241 static void hga_show_logo(struct fb_info *info)
242 {
243 /*
244 	void __iomem *dest = hga_vram;
245 	char *logo = linux_logo_bw;
246 	int x, y;
247 
248 	for (y = 134; y < 134 + 80 ; y++) * this needs some cleanup *
249 		for (x = 0; x < 10 ; x++)
250 			writeb(~*(logo++),(dest + HGA_ROWADDR(y) + x + 40));
251 */
252 }
253 
hga_pan(unsigned int xoffset,unsigned int yoffset)254 static void hga_pan(unsigned int xoffset, unsigned int yoffset)
255 {
256 	unsigned int base;
257 	unsigned long flags;
258 
259 	base = (yoffset / 8) * 90 + xoffset;
260 	spin_lock_irqsave(&hga_reg_lock, flags);
261 	write_hga_w(base, 0x0c);	/* start address */
262 	spin_unlock_irqrestore(&hga_reg_lock, flags);
263 	DPRINTK("hga_pan: base:%d\n", base);
264 }
265 
hga_blank(int blank_mode)266 static void hga_blank(int blank_mode)
267 {
268 	unsigned long flags;
269 
270 	spin_lock_irqsave(&hga_reg_lock, flags);
271 	if (blank_mode) {
272 		outb_p(0x00, HGA_MODE_PORT);	/* disable video */
273 	} else {
274 		outb_p(HGA_MODE_VIDEO_EN | HGA_MODE_GRAPHICS, HGA_MODE_PORT);
275 	}
276 	spin_unlock_irqrestore(&hga_reg_lock, flags);
277 }
278 
hga_card_detect(void)279 static int hga_card_detect(void)
280 {
281 	int count = 0;
282 	void __iomem *p, *q;
283 	unsigned short p_save, q_save;
284 
285 	hga_vram_len  = 0x08000;
286 
287 	hga_vram = ioremap(0xb0000, hga_vram_len);
288 	if (!hga_vram)
289 		return -ENOMEM;
290 
291 	if (request_region(0x3b0, 12, "hgafb"))
292 		release_io_ports = 1;
293 	if (request_region(0x3bf, 1, "hgafb"))
294 		release_io_port = 1;
295 
296 	/* do a memory check */
297 
298 	p = hga_vram;
299 	q = hga_vram + 0x01000;
300 
301 	p_save = readw(p); q_save = readw(q);
302 
303 	writew(0xaa55, p); if (readw(p) == 0xaa55) count++;
304 	writew(0x55aa, p); if (readw(p) == 0x55aa) count++;
305 	writew(p_save, p);
306 
307 	if (count != 2)
308 		goto error;
309 
310 	/* Ok, there is definitely a card registering at the correct
311 	 * memory location, so now we do an I/O port test.
312 	 */
313 
314 	if (!test_hga_b(0x66, 0x0f))	    /* cursor low register */
315 		goto error;
316 
317 	if (!test_hga_b(0x99, 0x0f))     /* cursor low register */
318 		goto error;
319 
320 	/* See if the card is a Hercules, by checking whether the vsync
321 	 * bit of the status register is changing.  This test lasts for
322 	 * approximately 1/10th of a second.
323 	 */
324 
325 	p_save = q_save = inb_p(HGA_STATUS_PORT) & HGA_STATUS_VSYNC;
326 
327 	for (count=0; count < 50000 && p_save == q_save; count++) {
328 		q_save = inb(HGA_STATUS_PORT) & HGA_STATUS_VSYNC;
329 		udelay(2);
330 	}
331 
332 	if (p_save == q_save)
333 		goto error;
334 
335 	switch (inb_p(HGA_STATUS_PORT) & 0x70) {
336 		case 0x10:
337 			hga_type = TYPE_HERCPLUS;
338 			hga_type_name = "HerculesPlus";
339 			break;
340 		case 0x50:
341 			hga_type = TYPE_HERCCOLOR;
342 			hga_type_name = "HerculesColor";
343 			break;
344 		default:
345 			hga_type = TYPE_HERC;
346 			hga_type_name = "Hercules";
347 			break;
348 	}
349 	return 0;
350 error:
351 	if (release_io_ports)
352 		release_region(0x3b0, 12);
353 	if (release_io_port)
354 		release_region(0x3bf, 1);
355 
356 	iounmap(hga_vram);
357 
358 	pr_err("hgafb: HGA card not detected.\n");
359 
360 	return -EINVAL;
361 }
362 
363 /**
364  *	hgafb_open - open the framebuffer device
365  *	@info: pointer to fb_info object containing info for current hga board
366  *	@init: open by console system or userland.
367  */
368 
hgafb_open(struct fb_info * info,int init)369 static int hgafb_open(struct fb_info *info, int init)
370 {
371 	hga_gfx_mode();
372 	hga_clear_screen();
373 	if (!nologo) hga_show_logo(info);
374 	return 0;
375 }
376 
377 /**
378  *	hgafb_release - open the framebuffer device
379  *	@info: pointer to fb_info object containing info for current hga board
380  *	@init: open by console system or userland.
381  */
382 
hgafb_release(struct fb_info * info,int init)383 static int hgafb_release(struct fb_info *info, int init)
384 {
385 	hga_txt_mode();
386 	hga_clear_screen();
387 	return 0;
388 }
389 
390 /**
391  *	hgafb_setcolreg - set color registers
392  *	@regno:register index to set
393  *	@red:red value, unused
394  *	@green:green value, unused
395  *	@blue:blue value, unused
396  *	@transp:transparency value, unused
397  *	@info:unused
398  *
399  *	This callback function is used to set the color registers of a HGA
400  *	board. Since we have only two fixed colors only @regno is checked.
401  *	A zero is returned on success and 1 for failure.
402  */
403 
hgafb_setcolreg(u_int regno,u_int red,u_int green,u_int blue,u_int transp,struct fb_info * info)404 static int hgafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
405 			   u_int transp, struct fb_info *info)
406 {
407 	if (regno > 1)
408 		return 1;
409 	return 0;
410 }
411 
412 /**
413  *	hga_pan_display - pan or wrap the display
414  *	@var:contains new xoffset, yoffset and vmode values
415  *	@info:pointer to fb_info object containing info for current hga board
416  *
417  *	This function looks only at xoffset, yoffset and the %FB_VMODE_YWRAP
418  *	flag in @var. If input parameters are correct it calls hga_pan() to
419  *	program the hardware. @info->var is updated to the new values.
420  *	A zero is returned on success and %-EINVAL for failure.
421  */
422 
hgafb_pan_display(struct fb_var_screeninfo * var,struct fb_info * info)423 static int hgafb_pan_display(struct fb_var_screeninfo *var,
424 			     struct fb_info *info)
425 {
426 	if (var->vmode & FB_VMODE_YWRAP) {
427 		if (var->yoffset >= info->var.yres_virtual ||
428 		    var->xoffset)
429 			return -EINVAL;
430 	} else {
431 		if (var->xoffset + info->var.xres > info->var.xres_virtual
432 		 || var->yoffset + info->var.yres > info->var.yres_virtual
433 		 || var->yoffset % 8)
434 			return -EINVAL;
435 	}
436 
437 	hga_pan(var->xoffset, var->yoffset);
438 	return 0;
439 }
440 
441 /**
442  *	hgafb_blank - (un)blank the screen
443  *	@blank_mode:blanking method to use
444  *	@info:unused
445  *
446  *	Blank the screen if blank_mode != 0, else unblank.
447  *	Implements VESA suspend and powerdown modes on hardware that supports
448  *	disabling hsync/vsync:
449  *		@blank_mode == 2 means suspend vsync,
450  *		@blank_mode == 3 means suspend hsync,
451  *		@blank_mode == 4 means powerdown.
452  */
453 
hgafb_blank(int blank_mode,struct fb_info * info)454 static int hgafb_blank(int blank_mode, struct fb_info *info)
455 {
456 	hga_blank(blank_mode);
457 	return 0;
458 }
459 
460 /*
461  * Accel functions
462  */
hgafb_fillrect(struct fb_info * info,const struct fb_fillrect * rect)463 static void hgafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
464 {
465 	u_int rows, y;
466 	u8 __iomem *dest;
467 
468 	y = rect->dy;
469 
470 	for (rows = rect->height; rows--; y++) {
471 		dest = rowaddr(info, y) + (rect->dx >> 3);
472 		switch (rect->rop) {
473 		case ROP_COPY:
474 			memset_io(dest, rect->color, (rect->width >> 3));
475 			break;
476 		case ROP_XOR:
477 			fb_writeb(~(fb_readb(dest)), dest);
478 			break;
479 		}
480 	}
481 }
482 
hgafb_copyarea(struct fb_info * info,const struct fb_copyarea * area)483 static void hgafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
484 {
485 	u_int rows, y1, y2;
486 	u8 __iomem *src;
487 	u8 __iomem *dest;
488 
489 	if (area->dy <= area->sy) {
490 		y1 = area->sy;
491 		y2 = area->dy;
492 
493 		for (rows = area->height; rows--; ) {
494 			src = rowaddr(info, y1) + (area->sx >> 3);
495 			dest = rowaddr(info, y2) + (area->dx >> 3);
496 			memmove(dest, src, (area->width >> 3));
497 			y1++;
498 			y2++;
499 		}
500 	} else {
501 		y1 = area->sy + area->height - 1;
502 		y2 = area->dy + area->height - 1;
503 
504 		for (rows = area->height; rows--;) {
505 			src = rowaddr(info, y1) + (area->sx >> 3);
506 			dest = rowaddr(info, y2) + (area->dx >> 3);
507 			memmove(dest, src, (area->width >> 3));
508 			y1--;
509 			y2--;
510 		}
511 	}
512 }
513 
hgafb_imageblit(struct fb_info * info,const struct fb_image * image)514 static void hgafb_imageblit(struct fb_info *info, const struct fb_image *image)
515 {
516 	u8 __iomem *dest;
517 	u8 *cdat = (u8 *) image->data;
518 	u_int rows, y = image->dy;
519 	u_int x;
520 	u8 d;
521 
522 	for (rows = image->height; rows--; y++) {
523 		for (x = 0; x < image->width; x+= 8) {
524 			d = *cdat++;
525 			dest = rowaddr(info, y) + ((image->dx + x)>> 3);
526 			fb_writeb(d, dest);
527 		}
528 	}
529 }
530 
531 static const struct fb_ops hgafb_ops = {
532 	.owner		= THIS_MODULE,
533 	.fb_open	= hgafb_open,
534 	.fb_release	= hgafb_release,
535 	.fb_setcolreg	= hgafb_setcolreg,
536 	.fb_pan_display	= hgafb_pan_display,
537 	.fb_blank	= hgafb_blank,
538 	.fb_fillrect	= hgafb_fillrect,
539 	.fb_copyarea	= hgafb_copyarea,
540 	.fb_imageblit	= hgafb_imageblit,
541 };
542 
543 /* ------------------------------------------------------------------------- *
544  *
545  * Functions in fb_info
546  *
547  * ------------------------------------------------------------------------- */
548 
549 /* ------------------------------------------------------------------------- */
550 
551 	/*
552 	 *  Initialization
553 	 */
554 
hgafb_probe(struct platform_device * pdev)555 static int hgafb_probe(struct platform_device *pdev)
556 {
557 	struct fb_info *info;
558 	int ret;
559 
560 	ret = hga_card_detect();
561 	if (ret)
562 		return ret;
563 
564 	printk(KERN_INFO "hgafb: %s with %ldK of memory detected.\n",
565 		hga_type_name, hga_vram_len/1024);
566 
567 	info = framebuffer_alloc(0, &pdev->dev);
568 	if (!info) {
569 		iounmap(hga_vram);
570 		return -ENOMEM;
571 	}
572 
573 	hga_fix.smem_start = (unsigned long)hga_vram;
574 	hga_fix.smem_len = hga_vram_len;
575 
576 	info->flags = FBINFO_HWACCEL_YPAN;
577 	info->var = hga_default_var;
578 	info->fix = hga_fix;
579 	info->monspecs.hfmin = 0;
580 	info->monspecs.hfmax = 0;
581 	info->monspecs.vfmin = 10000;
582 	info->monspecs.vfmax = 10000;
583 	info->monspecs.dpms = 0;
584 	info->fbops = &hgafb_ops;
585 	info->screen_base = hga_vram;
586 
587         if (register_framebuffer(info) < 0) {
588 		framebuffer_release(info);
589 		iounmap(hga_vram);
590 		return -EINVAL;
591 	}
592 
593 	fb_info(info, "%s frame buffer device\n", info->fix.id);
594 	platform_set_drvdata(pdev, info);
595 	return 0;
596 }
597 
hgafb_remove(struct platform_device * pdev)598 static void hgafb_remove(struct platform_device *pdev)
599 {
600 	struct fb_info *info = platform_get_drvdata(pdev);
601 
602 	hga_txt_mode();
603 	hga_clear_screen();
604 
605 	if (info) {
606 		unregister_framebuffer(info);
607 		framebuffer_release(info);
608 	}
609 
610 	iounmap(hga_vram);
611 
612 	if (release_io_ports)
613 		release_region(0x3b0, 12);
614 
615 	if (release_io_port)
616 		release_region(0x3bf, 1);
617 }
618 
619 static struct platform_driver hgafb_driver = {
620 	.probe = hgafb_probe,
621 	.remove_new = hgafb_remove,
622 	.driver = {
623 		.name = "hgafb",
624 	},
625 };
626 
627 static struct platform_device *hgafb_device;
628 
hgafb_init(void)629 static int __init hgafb_init(void)
630 {
631 	int ret;
632 
633 	if (fb_get_options("hgafb", NULL))
634 		return -ENODEV;
635 
636 	ret = platform_driver_register(&hgafb_driver);
637 
638 	if (!ret) {
639 		hgafb_device = platform_device_register_simple("hgafb", 0, NULL, 0);
640 
641 		if (IS_ERR(hgafb_device)) {
642 			platform_driver_unregister(&hgafb_driver);
643 			ret = PTR_ERR(hgafb_device);
644 		}
645 	}
646 
647 	return ret;
648 }
649 
hgafb_exit(void)650 static void __exit hgafb_exit(void)
651 {
652 	platform_device_unregister(hgafb_device);
653 	platform_driver_unregister(&hgafb_driver);
654 }
655 
656 /* -------------------------------------------------------------------------
657  *
658  *  Modularization
659  *
660  * ------------------------------------------------------------------------- */
661 
662 MODULE_AUTHOR("Ferenc Bakonyi (fero@drama.obuda.kando.hu)");
663 MODULE_DESCRIPTION("FBDev driver for Hercules Graphics Adaptor");
664 MODULE_LICENSE("GPL");
665 
666 module_param(nologo, bool, 0);
667 MODULE_PARM_DESC(nologo, "Disables startup logo if != 0 (default=0)");
668 module_init(hgafb_init);
669 module_exit(hgafb_exit);
670