1 /*
2  *  linux/drivers/video/sbusfb.c -- SBUS or UPA based frame buffer device
3  *
4  *	Copyright (C) 1998 Jakub Jelinek
5  *
6  *  This driver is partly based on the Open Firmware console driver
7  *
8  *	Copyright (C) 1997 Geert Uytterhoeven
9  *
10  *  and SPARC console subsystem
11  *
12  *      Copyright (C) 1995 Peter Zaitcev (zaitcev@yahoo.com)
13  *      Copyright (C) 1995-1997 David S. Miller (davem@caip.rutgers.edu)
14  *      Copyright (C) 1995-1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
15  *      Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
16  *      Copyright (C) 1996-1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
17  *      Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
18  *
19  *  This file is subject to the terms and conditions of the GNU General Public
20  *  License. See the file COPYING in the main directory of this archive for
21  *  more details.
22  */
23 
24 #include <linux/config.h>
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/string.h>
29 #include <linux/mm.h>
30 #include <linux/tty.h>
31 #include <linux/slab.h>
32 #include <linux/vmalloc.h>
33 #include <linux/delay.h>
34 #include <linux/interrupt.h>
35 #include <linux/fb.h>
36 #include <linux/selection.h>
37 #include <linux/init.h>
38 #include <linux/console.h>
39 #include <linux/kd.h>
40 #include <linux/vt_kern.h>
41 
42 #include <asm/uaccess.h>
43 #include <asm/pgtable.h>	/* io_remap_page_range() */
44 
45 #include <video/sbusfb.h>
46 
47 #define DEFAULT_CURSOR_BLINK_RATE       (2*HZ/5)
48 
49 #define CURSOR_SHAPE			1
50 #define CURSOR_BLINK			2
51 
52     /*
53      *  Interface used by the world
54      */
55 
56 int sbusfb_init(void);
57 int sbusfb_setup(char*);
58 
59 static int currcon;
60 static int defx_margin = -1, defy_margin = -1;
61 static char fontname[40] __initdata = { 0 };
62 static int curblink __initdata = 1;
63 static struct {
64 	int depth;
65 	int xres, yres;
66 	int x_margin, y_margin;
67 } def_margins [] = {
68 	{ 8, 1280, 1024, 64, 80 },
69 	{ 8, 1152, 1024, 64, 80 },
70 	{ 8, 1152, 900,  64, 18 },
71 	{ 8, 1024, 768,  0,  0 },
72 	{ 8, 800, 600, 16, 12 },
73 	{ 8, 640, 480, 0, 0 },
74 	{ 1, 1152, 900,  8,  18 },
75 	{ 0 },
76 };
77 
78 static int sbusfb_open(struct fb_info *info, int user);
79 static int sbusfb_release(struct fb_info *info, int user);
80 static int sbusfb_mmap(struct fb_info *info, struct file *file,
81 			struct vm_area_struct *vma);
82 static int sbusfb_get_fix(struct fb_fix_screeninfo *fix, int con,
83 			struct fb_info *info);
84 static int sbusfb_get_var(struct fb_var_screeninfo *var, int con,
85 			struct fb_info *info);
86 static int sbusfb_set_var(struct fb_var_screeninfo *var, int con,
87 			struct fb_info *info);
88 static int sbusfb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
89 			struct fb_info *info);
90 static int sbusfb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
91 			struct fb_info *info);
92 static int sbusfb_ioctl(struct inode *inode, struct file *file, u_int cmd,
93 			    u_long arg, int con, struct fb_info *info);
94 static void sbusfb_cursor(struct display *p, int mode, int x, int y);
95 static void sbusfb_clear_margin(struct display *p, int s);
96 
97 
98     /*
99      *  Interface to the low level console driver
100      */
101 
102 static int sbusfbcon_switch(int con, struct fb_info *info);
103 static int sbusfbcon_updatevar(int con, struct fb_info *info);
104 static void sbusfbcon_blank(int blank, struct fb_info *info);
105 
106 
107     /*
108      *  Internal routines
109      */
110 
111 static int sbusfb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
112 			    u_int *transp, struct fb_info *info);
113 static int sbusfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
114 			    u_int transp, struct fb_info *info);
115 static void do_install_cmap(int con, struct fb_info *info);
116 
117 static struct fb_ops sbusfb_ops = {
118 	owner:		THIS_MODULE,
119 	fb_open:	sbusfb_open,
120 	fb_release:	sbusfb_release,
121 	fb_get_fix:	sbusfb_get_fix,
122 	fb_get_var:	sbusfb_get_var,
123 	fb_set_var:	sbusfb_set_var,
124 	fb_get_cmap:	sbusfb_get_cmap,
125 	fb_set_cmap:	sbusfb_set_cmap,
126 	fb_ioctl:	sbusfb_ioctl,
127 	fb_mmap:	sbusfb_mmap,
128 };
129 
130     /*
131      *  Open/Release the frame buffer device
132      */
133 
sbusfb_open(struct fb_info * info,int user)134 static int sbusfb_open(struct fb_info *info, int user)
135 {
136 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
137 
138 	if (user) {
139 		if (fb->open == 0) {
140 			fb->mmaped = 0;
141 			fb->vtconsole = -1;
142 		}
143 		fb->open++;
144 	} else
145 		fb->consolecnt++;
146 	return 0;
147 }
148 
sbusfb_release(struct fb_info * info,int user)149 static int sbusfb_release(struct fb_info *info, int user)
150 {
151 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
152 
153 	if (user) {
154 		fb->open--;
155 		if (fb->open == 0) {
156 			if (fb->vtconsole != -1) {
157 				vt_cons[fb->vtconsole]->vc_mode = KD_TEXT;
158 				if (fb->mmaped) {
159 					fb->graphmode--;
160 					sbusfb_clear_margin(&fb_display[fb->vtconsole], 0);
161 				}
162 			}
163 			if (fb->reset)
164 				fb->reset(fb);
165 		}
166 	} else
167 		fb->consolecnt--;
168 	return 0;
169 }
170 
sbusfb_mmapsize(struct fb_info_sbusfb * fb,long size)171 static unsigned long sbusfb_mmapsize(struct fb_info_sbusfb *fb, long size)
172 {
173 	if (size == SBUS_MMAP_EMPTY) return 0;
174 	if (size >= 0) return size;
175 	return fb->type.fb_size * (-size);
176 }
177 
sbusfb_mmap(struct fb_info * info,struct file * file,struct vm_area_struct * vma)178 static int sbusfb_mmap(struct fb_info *info, struct file *file,
179 			struct vm_area_struct *vma)
180 {
181 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
182 	unsigned int size, page, r, map_size;
183 	unsigned long map_offset = 0;
184 	unsigned long off;
185 	int i;
186 
187 	size = vma->vm_end - vma->vm_start;
188 	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
189 		return -EINVAL;
190 
191 	off = vma->vm_pgoff << PAGE_SHIFT;
192 
193 	/* To stop the swapper from even considering these pages */
194 	vma->vm_flags |= (VM_SHM| VM_LOCKED);
195 
196 
197 	/* Each page, see which map applies */
198 	for (page = 0; page < size; ){
199 		map_size = 0;
200 		for (i = 0; fb->mmap_map[i].size; i++)
201 			if (fb->mmap_map[i].voff == off+page) {
202 				map_size = sbusfb_mmapsize(fb,fb->mmap_map[i].size);
203 #ifdef __sparc_v9__
204 #define POFF_MASK	(PAGE_MASK|0x1UL)
205 #else
206 #define POFF_MASK	(PAGE_MASK)
207 #endif
208 				map_offset = (fb->physbase + fb->mmap_map[i].poff) & POFF_MASK;
209 				break;
210 			}
211 		if (!map_size){
212 			page += PAGE_SIZE;
213 			continue;
214 		}
215 		if (page + map_size > size)
216 			map_size = size - page;
217 		r = io_remap_page_range (vma->vm_start+page, map_offset, map_size, vma->vm_page_prot, fb->iospace);
218 		if (r)
219 			return -EAGAIN;
220 		page += map_size;
221 	}
222 
223 	vma->vm_flags |= VM_IO;
224 	if (!fb->mmaped) {
225 		int lastconsole = 0;
226 
227 		if (info->display_fg)
228 			lastconsole = info->display_fg->vc_num;
229 		fb->mmaped = 1;
230 		if (fb->consolecnt && fb_display[lastconsole].fb_info == info) {
231 			fb->vtconsole = lastconsole;
232 			fb->graphmode++;
233 			vt_cons [lastconsole]->vc_mode = KD_GRAPHICS;
234 			vc_cons[lastconsole].d->vc_sw->con_cursor(vc_cons[lastconsole].d,CM_ERASE);
235 		} else if (fb->unblank && !fb->blanked)
236 			(*fb->unblank)(fb);
237 	}
238 	return 0;
239 }
240 
sbusfb_clear_margin(struct display * p,int s)241 static void sbusfb_clear_margin(struct display *p, int s)
242 {
243 	struct fb_info_sbusfb *fb = sbusfbinfod(p);
244 
245 	if (fb->switch_from_graph)
246 		(*fb->switch_from_graph)(fb);
247 	if (fb->fill) {
248 		unsigned short rects [16];
249 
250 		rects [0] = 0;
251 		rects [1] = 0;
252 		rects [2] = fb->var.xres_virtual;
253 		rects [3] = fb->y_margin;
254 		rects [4] = 0;
255 		rects [5] = fb->y_margin;
256 		rects [6] = fb->x_margin;
257 		rects [7] = fb->var.yres_virtual;
258 		rects [8] = fb->var.xres_virtual - fb->x_margin;
259 		rects [9] = fb->y_margin;
260 		rects [10] = fb->var.xres_virtual;
261 		rects [11] = fb->var.yres_virtual;
262 		rects [12] = fb->x_margin;
263 		rects [13] = fb->var.yres_virtual - fb->y_margin;
264 		rects [14] = fb->var.xres_virtual - fb->x_margin;
265 		rects [15] = fb->var.yres_virtual;
266 		(*fb->fill)(fb, p, s, 4, rects);
267 	} else {
268 		unsigned char *fb_base = p->screen_base, *q;
269 		int skip_bytes = fb->y_margin * fb->var.xres_virtual;
270 		int scr_size = fb->var.xres_virtual * fb->var.yres_virtual;
271 		int h, he, incr, size;
272 
273 		he = fb->var.yres;
274 		if (fb->var.bits_per_pixel == 1) {
275 			fb_base -= (skip_bytes + fb->x_margin) / 8;
276 			skip_bytes /= 8;
277 			scr_size /= 8;
278 			fb_memset255 (fb_base, skip_bytes - fb->x_margin / 8);
279 			fb_memset255 (fb_base + scr_size - skip_bytes + fb->x_margin / 8, skip_bytes - fb->x_margin / 8);
280 			incr = fb->var.xres_virtual / 8;
281 			size = fb->x_margin / 8 * 2;
282 			for (q = fb_base + skip_bytes - fb->x_margin / 8, h = 0;
283 			     h <= he; q += incr, h++)
284 				fb_memset255 (q, size);
285 		} else {
286 			fb_base -= (skip_bytes + fb->x_margin);
287 			memset (fb_base, attr_bgcol(p,s), skip_bytes - fb->x_margin);
288 			memset (fb_base + scr_size - skip_bytes + fb->x_margin, attr_bgcol(p,s), skip_bytes - fb->x_margin);
289 			incr = fb->var.xres_virtual;
290 			size = fb->x_margin * 2;
291 			for (q = fb_base + skip_bytes - fb->x_margin, h = 0;
292 			     h <= he; q += incr, h++)
293 				memset (q, attr_bgcol(p,s), size);
294 		}
295 	}
296 }
297 
sbusfb_disp_setup(struct display * p)298 static void sbusfb_disp_setup(struct display *p)
299 {
300 	struct fb_info_sbusfb *fb = sbusfbinfod(p);
301 
302 	if (fb->setup)
303 		fb->setup(p);
304 	sbusfb_clear_margin(p, 0);
305 }
306 
307     /*
308      *  Get the Fixed Part of the Display
309      */
310 
sbusfb_get_fix(struct fb_fix_screeninfo * fix,int con,struct fb_info * info)311 static int sbusfb_get_fix(struct fb_fix_screeninfo *fix, int con,
312 			  struct fb_info *info)
313 {
314 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
315 
316 	memcpy(fix, &fb->fix, sizeof(struct fb_fix_screeninfo));
317 	return 0;
318 }
319 
320     /*
321      *  Get the User Defined Part of the Display
322      */
323 
sbusfb_get_var(struct fb_var_screeninfo * var,int con,struct fb_info * info)324 static int sbusfb_get_var(struct fb_var_screeninfo *var, int con,
325 			  struct fb_info *info)
326 {
327 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
328 
329 	memcpy(var, &fb->var, sizeof(struct fb_var_screeninfo));
330 	return 0;
331 }
332 
333     /*
334      *  Set the User Defined Part of the Display
335      */
336 
sbusfb_set_var(struct fb_var_screeninfo * var,int con,struct fb_info * info)337 static int sbusfb_set_var(struct fb_var_screeninfo *var, int con,
338 			  struct fb_info *info)
339 {
340        struct display *display;
341        int activate = var->activate;
342 
343        if(con >= 0)
344                display = &fb_display[con];
345        else
346                display = info->disp;
347 
348        /* simple check for equality until fully implemented -E */
349        if ((activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
350                if (display->var.xres != var->xres ||
351                        display->var.yres != var->yres ||
352                        display->var.xres_virtual != var->xres_virtual ||
353                        display->var.yres_virtual != var->yres_virtual ||
354                        display->var.bits_per_pixel != var->bits_per_pixel ||
355                        display->var.accel_flags != var->accel_flags) {
356                        return -EINVAL;
357                }
358        }
359        return 0;
360 
361 }
362 
363     /*
364      *  Hardware cursor
365      */
366 
sbus_hw_scursor(struct fbcursor * cursor,struct fb_info_sbusfb * fb)367 static int sbus_hw_scursor (struct fbcursor *cursor, struct fb_info_sbusfb *fb)
368 {
369 	int op;
370 	int i, bytes = 0;
371 	struct fbcursor f;
372 	char red[2], green[2], blue[2];
373 
374 	if (copy_from_user (&f, cursor, sizeof(struct fbcursor)))
375 		return -EFAULT;
376 	op = f.set;
377 	if (op & FB_CUR_SETSHAPE){
378 		if ((u32) f.size.fbx > fb->cursor.hwsize.fbx)
379 			return -EINVAL;
380 		if ((u32) f.size.fby > fb->cursor.hwsize.fby)
381 			return -EINVAL;
382 		if (f.size.fbx > 32)
383 			bytes = f.size.fby << 3;
384 		else
385 			bytes = f.size.fby << 2;
386 	}
387 	if (op & FB_CUR_SETCMAP){
388 		if (f.cmap.index || f.cmap.count != 2)
389 			return -EINVAL;
390 		if (copy_from_user (red, f.cmap.red, 2) ||
391 		    copy_from_user (green, f.cmap.green, 2) ||
392 		    copy_from_user (blue, f.cmap.blue, 2))
393 			return -EFAULT;
394 	}
395 	if (op & FB_CUR_SETCMAP)
396 		(*fb->setcursormap) (fb, red, green, blue);
397 	if (op & FB_CUR_SETSHAPE){
398 		u32 u;
399 
400 		fb->cursor.size = f.size;
401 		memset ((void *)&fb->cursor.bits, 0, sizeof (fb->cursor.bits));
402 		if (copy_from_user (fb->cursor.bits [0], f.mask, bytes) ||
403 		    copy_from_user (fb->cursor.bits [1], f.image, bytes))
404 			return -EFAULT;
405 		if (f.size.fbx <= 32) {
406 			u = 0xffffffff << (32 - f.size.fbx);
407 			for (i = fb->cursor.size.fby - 1; i >= 0; i--) {
408 				fb->cursor.bits [0][i] &= u;
409 				fb->cursor.bits [1][i] &= fb->cursor.bits [0][i];
410 			}
411 		} else {
412 			u = 0xffffffff << (64 - f.size.fbx);
413 			for (i = fb->cursor.size.fby - 1; i >= 0; i--) {
414 				fb->cursor.bits [0][2*i+1] &= u;
415 				fb->cursor.bits [1][2*i] &= fb->cursor.bits [0][2*i];
416 				fb->cursor.bits [1][2*i+1] &= fb->cursor.bits [0][2*i+1];
417 			}
418 		}
419 		(*fb->setcurshape) (fb);
420 	}
421 	if (op & (FB_CUR_SETCUR | FB_CUR_SETPOS | FB_CUR_SETHOT)){
422 		if (op & FB_CUR_SETCUR)
423 			fb->cursor.enable = f.enable;
424 		if (op & FB_CUR_SETPOS)
425 			fb->cursor.cpos = f.pos;
426 		if (op & FB_CUR_SETHOT)
427 			fb->cursor.chot = f.hot;
428 		(*fb->setcursor) (fb);
429 	}
430 	return 0;
431 }
432 
433 static unsigned char hw_cursor_cmap[2] = { 0, 0xff };
434 
435 static void
sbusfb_cursor_timer_handler(unsigned long dev_addr)436 sbusfb_cursor_timer_handler(unsigned long dev_addr)
437 {
438 	struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)dev_addr;
439 
440 	if (!fb->setcursor) return;
441 
442 	if (fb->cursor.mode & CURSOR_BLINK) {
443 		fb->cursor.enable ^= 1;
444 		fb->setcursor(fb);
445 	}
446 
447 	fb->cursor.timer.expires = jiffies + fb->cursor.blink_rate;
448 	add_timer(&fb->cursor.timer);
449 }
450 
sbusfb_cursor(struct display * p,int mode,int x,int y)451 static void sbusfb_cursor(struct display *p, int mode, int x, int y)
452 {
453 	struct fb_info_sbusfb *fb = sbusfbinfod(p);
454 
455 	switch (mode) {
456 	case CM_ERASE:
457 		fb->cursor.mode &= ~CURSOR_BLINK;
458 		fb->cursor.enable = 0;
459 		(*fb->setcursor)(fb);
460 		break;
461 
462 	case CM_MOVE:
463 	case CM_DRAW:
464 		if (fb->cursor.mode & CURSOR_SHAPE) {
465 			fb->cursor.size.fbx = fontwidth(p);
466 			fb->cursor.size.fby = fontheight(p);
467 			fb->cursor.chot.fbx = 0;
468 			fb->cursor.chot.fby = 0;
469 			fb->cursor.enable = 1;
470 			memset (fb->cursor.bits, 0, sizeof (fb->cursor.bits));
471 			fb->cursor.bits[0][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
472 			fb->cursor.bits[1][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
473 			fb->cursor.bits[0][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
474 			fb->cursor.bits[1][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
475 			(*fb->setcursormap) (fb, hw_cursor_cmap, hw_cursor_cmap, hw_cursor_cmap);
476 			(*fb->setcurshape) (fb);
477 		}
478 		fb->cursor.mode = CURSOR_BLINK;
479 		if (fontwidthlog(p))
480 			fb->cursor.cpos.fbx = (x << fontwidthlog(p)) + fb->x_margin;
481 		else
482 			fb->cursor.cpos.fbx = (x * fontwidth(p)) + fb->x_margin;
483 		if (fontheightlog(p))
484 			fb->cursor.cpos.fby = (y << fontheightlog(p)) + fb->y_margin;
485 		else
486 			fb->cursor.cpos.fby = (y * fontheight(p)) + fb->y_margin;
487 		(*fb->setcursor)(fb);
488 		break;
489 	}
490 }
491 
492     /*
493      *  Get the Colormap
494      */
495 
sbusfb_get_cmap(struct fb_cmap * cmap,int kspc,int con,struct fb_info * info)496 static int sbusfb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
497 			 struct fb_info *info)
498 {
499 	if (!info->display_fg || con == info->display_fg->vc_num) /* current console? */
500 		return fb_get_cmap(cmap, kspc, sbusfb_getcolreg, info);
501 	else if (fb_display[con].cmap.len) /* non default colormap? */
502 		fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
503 	else
504 		fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel), cmap, kspc ? 0 : 2);
505 	return 0;
506 }
507 
508     /*
509      *  Set the Colormap
510      */
511 
sbusfb_set_cmap(struct fb_cmap * cmap,int kspc,int con,struct fb_info * info)512 static int sbusfb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
513 			 struct fb_info *info)
514 {
515 	int err;
516 	struct display *disp;
517 
518 	if (con >= 0)
519 		disp = &fb_display[con];
520 	else
521 		disp = info->disp;
522 	if (!disp->cmap.len) {	/* no colormap allocated? */
523 		if ((err = fb_alloc_cmap(&disp->cmap, 1<<disp->var.bits_per_pixel, 0)))
524 			return err;
525 	}
526 	if (con == currcon) {			/* current console? */
527 		err = fb_set_cmap(cmap, kspc, sbusfb_setcolreg, info);
528 		if (!err) {
529 			struct fb_info_sbusfb *fb = sbusfbinfo(info);
530 
531 			if (fb->loadcmap)
532 				(*fb->loadcmap)(fb, &fb_display[con], cmap->start, cmap->len);
533 		}
534 		return err;
535 	} else
536 		fb_copy_cmap(cmap, &disp->cmap, kspc ? 0 : 1);
537 	return 0;
538 }
539 
sbusfb_ioctl(struct inode * inode,struct file * file,u_int cmd,u_long arg,int con,struct fb_info * info)540 static int sbusfb_ioctl(struct inode *inode, struct file *file, u_int cmd,
541 			u_long arg, int con, struct fb_info *info)
542 {
543 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
544 	int i;
545 	int lastconsole;
546 
547 	switch (cmd){
548 	case FBIOGTYPE:		/* return frame buffer type */
549 		if (copy_to_user((struct fbtype *)arg, &fb->type, sizeof(struct fbtype)))
550 			return -EFAULT;
551 		break;
552 	case FBIOGATTR: {
553 		struct fbgattr *fba = (struct fbgattr *) arg;
554 
555 		i = verify_area (VERIFY_WRITE, (void *) arg, sizeof (struct fbgattr));
556 		if (i) return i;
557 		if (__put_user(fb->emulations[0], &fba->real_type) ||
558 		    __put_user(0, &fba->owner) ||
559 		    __copy_to_user(&fba->fbtype, &fb->type,
560 				   sizeof(struct fbtype)) ||
561 		    __put_user(0, &fba->sattr.flags) ||
562 		    __put_user(fb->type.fb_type, &fba->sattr.emu_type) ||
563 		    __put_user(-1, &fba->sattr.dev_specific[0]))
564 			return -EFAULT;
565 		for (i = 0; i < 4; i++) {
566 			if (put_user(fb->emulations[i], &fba->emu_types[i]))
567 				return -EFAULT;
568 		}
569 		break;
570 	}
571 	case FBIOSATTR:
572 		i = verify_area (VERIFY_READ, (void *) arg, sizeof (struct fbsattr));
573 		if (i) return i;
574 		return -EINVAL;
575 	case FBIOSVIDEO:
576 		if (fb->consolecnt) {
577 			lastconsole = info->display_fg->vc_num;
578 			if (vt_cons[lastconsole]->vc_mode == KD_TEXT)
579  				break;
580  		}
581 		if (get_user(i, (int *)arg))
582 			return -EFAULT;
583 		if (i){
584 			if (!fb->blanked || !fb->unblank)
585 				break;
586 			if (fb->consolecnt || (fb->open && fb->mmaped))
587 				(*fb->unblank)(fb);
588 			fb->blanked = 0;
589 		} else {
590 			if (fb->blanked || !fb->blank)
591 				break;
592 			(*fb->blank)(fb);
593 			fb->blanked = 1;
594 		}
595 		break;
596 	case FBIOGVIDEO:
597 		if (put_user(fb->blanked, (int *) arg))
598 			return -EFAULT;
599 		break;
600 	case FBIOGETCMAP_SPARC: {
601 		char *rp, *gp, *bp;
602 		int end, count, index;
603 		struct fbcmap *cmap;
604 
605 		if (!fb->loadcmap)
606 			return -EINVAL;
607 		i = verify_area (VERIFY_READ, (void *) arg, sizeof (struct fbcmap));
608 		if (i) return i;
609 		cmap = (struct fbcmap *) arg;
610 		if (__get_user(count, &cmap->count) ||
611 		    __get_user(index, &cmap->index))
612 			return -EFAULT;
613 		if ((index < 0) || (index > 255))
614 			return -EINVAL;
615 		if (index + count > 256)
616 			count = 256 - index;
617 		if (__get_user(rp, &cmap->red) ||
618 		    __get_user(gp, &cmap->green) ||
619 		    __get_user(bp, &cmap->blue))
620 			return -EFAULT;
621 		if (verify_area (VERIFY_WRITE, rp, count))
622 			return -EFAULT;
623 		if (verify_area (VERIFY_WRITE, gp, count))
624 			return -EFAULT;
625 		if (verify_area (VERIFY_WRITE, bp, count))
626 			return -EFAULT;
627 		end = index + count;
628 		for (i = index; i < end; i++){
629 			if (__put_user(fb->color_map CM(i,0), rp) ||
630 			    __put_user(fb->color_map CM(i,1), gp) ||
631 			    __put_user(fb->color_map CM(i,2), bp))
632 				return -EFAULT;
633 			rp++; gp++; bp++;
634 		}
635 		(*fb->loadcmap)(fb, NULL, index, count);
636 		break;
637 	}
638 	case FBIOPUTCMAP_SPARC: {	/* load color map entries */
639 		char *rp, *gp, *bp;
640 		int end, count, index;
641 		struct fbcmap *cmap;
642 
643 		if (!fb->loadcmap || !fb->color_map)
644 			return -EINVAL;
645 		i = verify_area (VERIFY_READ, (void *) arg, sizeof (struct fbcmap));
646 		if (i) return i;
647 		cmap = (struct fbcmap *) arg;
648 		if (__get_user(count, &cmap->count) ||
649 		    __get_user(index, &cmap->index))
650 			return -EFAULT;
651 		if ((index < 0) || (index > 255))
652 			return -EINVAL;
653 		if (index + count > 256)
654 			count = 256 - index;
655 		if (__get_user(rp, &cmap->red) ||
656 		    __get_user(gp, &cmap->green) ||
657 		    __get_user(bp, &cmap->blue))
658 			return -EFAULT;
659 		if (verify_area (VERIFY_READ, rp, count))
660 			return -EFAULT;
661 		if (verify_area (VERIFY_READ, gp, count))
662 			return -EFAULT;
663 		if (verify_area (VERIFY_READ, bp, count))
664 			return -EFAULT;
665 
666 		end = index + count;
667 		for (i = index; i < end; i++){
668 			if (__get_user(fb->color_map CM(i,0), rp))
669 				return -EFAULT;
670 			if (__get_user(fb->color_map CM(i,1), gp))
671 				return -EFAULT;
672 			if (__get_user(fb->color_map CM(i,2), bp))
673 				return -EFAULT;
674 			rp++; gp++; bp++;
675 		}
676 		(*fb->loadcmap)(fb, NULL, index, count);
677 		break;
678 	}
679 	case FBIOGCURMAX: {
680 		struct fbcurpos *p = (struct fbcurpos *) arg;
681 		if (!fb->setcursor) return -EINVAL;
682 		if(verify_area (VERIFY_WRITE, p, sizeof (struct fbcurpos)))
683 			return -EFAULT;
684 		if (__put_user(fb->cursor.hwsize.fbx, &p->fbx) ||
685 		    __put_user(fb->cursor.hwsize.fby, &p->fby))
686 			return -EFAULT;
687 		break;
688 	}
689 	case FBIOSCURSOR:
690 		if (!fb->setcursor) return -EINVAL;
691  		if (fb->consolecnt) {
692  			lastconsole = info->display_fg->vc_num;
693  			if (vt_cons[lastconsole]->vc_mode == KD_TEXT)
694  				return -EINVAL; /* Don't let graphics programs hide our nice text cursor */
695 			fb->cursor.mode = CURSOR_SHAPE; /* Forget state of our text cursor */
696 		}
697 		return sbus_hw_scursor ((struct fbcursor *) arg, fb);
698 
699 	case FBIOSCURPOS:
700 		if (!fb->setcursor) return -EINVAL;
701 		/* Don't let graphics programs move our nice text cursor */
702  		if (fb->consolecnt) {
703  			lastconsole = info->display_fg->vc_num;
704  			if (vt_cons[lastconsole]->vc_mode == KD_TEXT)
705  				return -EINVAL; /* Don't let graphics programs move our nice text cursor */
706  		}
707 		if (copy_from_user(&fb->cursor.cpos, (void *)arg, sizeof(struct fbcurpos)))
708 			return -EFAULT;
709 		(*fb->setcursor) (fb);
710 		break;
711 	default:
712 		if (fb->ioctl)
713 			return fb->ioctl(fb, cmd, arg);
714 		return -EINVAL;
715 	}
716 	return 0;
717 }
718 
719     /*
720      *  Setup: parse used options
721      */
722 
sbusfb_setup(char * options)723 int __init sbusfb_setup(char *options)
724 {
725 	char *p;
726 
727 	for (p = options;;) {
728 		if (!strncmp(p, "nomargins", 9)) {
729 			defx_margin = 0; defy_margin = 0;
730 		} else if (!strncmp(p, "margins=", 8)) {
731 			int i, j;
732 			char *q;
733 
734 			i = simple_strtoul(p+8,&q,10);
735 			if (i >= 0 && *q == 'x') {
736 			    j = simple_strtoul(q+1,&q,10);
737 			    if (j >= 0 && (*q == ' ' || !*q)) {
738 			    	defx_margin = i; defy_margin = j;
739 			    }
740 			}
741 		} else if (!strncmp(p, "font=", 5)) {
742 			int i;
743 
744 			for (i = 0; i < sizeof(fontname) - 1; i++)
745 				if (p[i+5] == ' ' || !p[i+5])
746 					break;
747 			memcpy(fontname, p+5, i);
748 			fontname[i] = 0;
749 		} else if (!strncmp(p, "noblink", 7))
750 			curblink = 0;
751 		while (*p && *p != ' ' && *p != ',') p++;
752 		if (*p != ',') break;
753 		p++;
754 	}
755 	return 0;
756 }
757 
sbusfbcon_switch(int con,struct fb_info * info)758 static int sbusfbcon_switch(int con, struct fb_info *info)
759 {
760 	int x_margin, y_margin;
761 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
762 	int lastconsole;
763 
764 	/* Do we have to save the colormap? */
765 	if (fb_display[currcon].cmap.len)
766 		fb_get_cmap(&fb_display[currcon].cmap, 1, sbusfb_getcolreg, info);
767 
768 	if (info->display_fg) {
769 		lastconsole = info->display_fg->vc_num;
770 		if (lastconsole != con &&
771 		    (fontwidth(&fb_display[lastconsole]) != fontwidth(&fb_display[con]) ||
772 		     fontheight(&fb_display[lastconsole]) != fontheight(&fb_display[con])))
773 			fb->cursor.mode |= CURSOR_SHAPE;
774 	}
775 	x_margin = (fb_display[con].var.xres_virtual - fb_display[con].var.xres) / 2;
776 	y_margin = (fb_display[con].var.yres_virtual - fb_display[con].var.yres) / 2;
777 	if (fb->margins)
778 		fb->margins(fb, &fb_display[con], x_margin, y_margin);
779 	if (fb->graphmode || fb->x_margin != x_margin || fb->y_margin != y_margin) {
780 		fb->x_margin = x_margin; fb->y_margin = y_margin;
781 		sbusfb_clear_margin(&fb_display[con], 0);
782 	}
783 	currcon = con;
784 	/* Install new colormap */
785 	do_install_cmap(con, info);
786 	return 0;
787 }
788 
789     /*
790      *  Update the `var' structure (called by fbcon.c)
791      */
792 
sbusfbcon_updatevar(int con,struct fb_info * info)793 static int sbusfbcon_updatevar(int con, struct fb_info *info)
794 {
795 	/* Nothing */
796 	return 0;
797 }
798 
799     /*
800      *  Blank the display.
801      */
802 
sbusfbcon_blank(int blank,struct fb_info * info)803 static void sbusfbcon_blank(int blank, struct fb_info *info)
804 {
805     struct fb_info_sbusfb *fb = sbusfbinfo(info);
806 
807     if (blank && fb->blank)
808     	return fb->blank(fb);
809     else if (!blank && fb->unblank)
810     	return fb->unblank(fb);
811 }
812 
813     /*
814      *  Read a single color register and split it into
815      *  colors/transparent. Return != 0 for invalid regno.
816      */
817 
sbusfb_getcolreg(u_int regno,u_int * red,u_int * green,u_int * blue,u_int * transp,struct fb_info * info)818 static int sbusfb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
819 			  u_int *transp, struct fb_info *info)
820 {
821 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
822 
823 	if (!fb->color_map || regno > 255)
824 		return 1;
825 	*red = (fb->color_map CM(regno, 0)<<8) | fb->color_map CM(regno, 0);
826 	*green = (fb->color_map CM(regno, 1)<<8) | fb->color_map CM(regno, 1);
827 	*blue = (fb->color_map CM(regno, 2)<<8) | fb->color_map CM(regno, 2);
828 	*transp = 0;
829 	return 0;
830 }
831 
832 
833     /*
834      *  Set a single color register. The values supplied are already
835      *  rounded down to the hardware's capabilities (according to the
836      *  entries in the var structure). Return != 0 for invalid regno.
837      */
838 
sbusfb_setcolreg(u_int regno,u_int red,u_int green,u_int blue,u_int transp,struct fb_info * info)839 static int sbusfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
840 			    u_int transp, struct fb_info *info)
841 {
842 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
843 
844 	if (!fb->color_map || regno > 255)
845 		return 1;
846 	red >>= 8;
847 	green >>= 8;
848 	blue >>= 8;
849 	fb->color_map CM(regno, 0) = red;
850 	fb->color_map CM(regno, 1) = green;
851 	fb->color_map CM(regno, 2) = blue;
852 	return 0;
853 }
854 
855 
do_install_cmap(int con,struct fb_info * info)856 static void do_install_cmap(int con, struct fb_info *info)
857 {
858 	struct fb_info_sbusfb *fb = sbusfbinfo(info);
859 
860 	if (con != currcon)
861 		return;
862 	if (fb_display[con].cmap.len)
863 		fb_set_cmap(&fb_display[con].cmap, 1, sbusfb_setcolreg, info);
864 	else
865 		fb_set_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
866 			    1, sbusfb_setcolreg, info);
867 	if (fb->loadcmap)
868 		(*fb->loadcmap)(fb, &fb_display[con], 0, 256);
869 }
870 
sbusfb_set_font(struct display * p,int width,int height)871 static int sbusfb_set_font(struct display *p, int width, int height)
872 {
873 	int margin;
874 	int w = p->var.xres_virtual, h = p->var.yres_virtual;
875 	int depth = p->var.bits_per_pixel;
876 	struct fb_info_sbusfb *fb = sbusfbinfod(p);
877 	int x_margin, y_margin;
878 
879 	if (depth > 8) depth = 8;
880 	x_margin = 0;
881 	y_margin = 0;
882 	if (defx_margin < 0 || defy_margin < 0) {
883 		for (margin = 0; def_margins[margin].depth; margin++)
884 			if (w == def_margins[margin].xres &&
885 			    h == def_margins[margin].yres &&
886 			    depth == def_margins[margin].depth) {
887 				x_margin = def_margins[margin].x_margin;
888 				y_margin = def_margins[margin].y_margin;
889 				break;
890 			}
891 	} else {
892 		x_margin = defx_margin;
893 		y_margin = defy_margin;
894 	}
895 	x_margin += ((w - 2*x_margin) % width) / 2;
896 	y_margin += ((h - 2*y_margin) % height) / 2;
897 
898 	p->var.xres = w - 2*x_margin;
899 	p->var.yres = h - 2*y_margin;
900 
901 	fb->cursor.mode |= CURSOR_SHAPE;
902 
903 	if (fb->margins)
904 		fb->margins(fb, p, x_margin, y_margin);
905 	if (fb->x_margin != x_margin || fb->y_margin != y_margin) {
906 		fb->x_margin = x_margin; fb->y_margin = y_margin;
907 		sbusfb_clear_margin(p, 0);
908 	}
909 
910 	return 1;
911 }
912 
sbusfb_palette(int enter)913 void sbusfb_palette(int enter)
914 {
915 	int i;
916 	struct display *p;
917 
918 	for (i = 0; i < MAX_NR_CONSOLES; i++) {
919 		p = &fb_display[i];
920 		if (p->dispsw && p->dispsw->setup == sbusfb_disp_setup &&
921 		    p->fb_info->display_fg &&
922 		    p->fb_info->display_fg->vc_num == i) {
923 			struct fb_info_sbusfb *fb = sbusfbinfod(p);
924 
925 			if (fb->restore_palette) {
926 				if (enter)
927 					fb->restore_palette(fb);
928 				else if (vt_cons[i]->vc_mode != KD_GRAPHICS)
929 				         vc_cons[i].d->vc_sw->con_set_palette(vc_cons[i].d, color_table);
930 			}
931 		}
932 	}
933 }
934 
935     /*
936      *  Initialisation
937      */
938 
939 extern void (*prom_palette)(int);
940 
sbusfb_init_fb(int node,int parent,int fbtype,struct sbus_dev * sbdp)941 static void __init sbusfb_init_fb(int node, int parent, int fbtype,
942 				  struct sbus_dev *sbdp)
943 {
944 	struct fb_fix_screeninfo *fix;
945 	struct fb_var_screeninfo *var;
946 	struct display *disp;
947 	struct fb_info_sbusfb *fb;
948 	struct fbtype *type;
949 	int linebytes, w, h, depth;
950 	char *p = NULL;
951 	int margin;
952 
953 	fb = kmalloc(sizeof(struct fb_info_sbusfb), GFP_ATOMIC);
954 	if (!fb) {
955 		prom_printf("Could not allocate sbusfb structure\n");
956 		return;
957 	}
958 
959 	if (!prom_palette)
960 		prom_palette = sbusfb_palette;
961 
962 	memset(fb, 0, sizeof(struct fb_info_sbusfb));
963 	fix = &fb->fix;
964 	var = &fb->var;
965 	disp = &fb->disp;
966 	type = &fb->type;
967 
968 	spin_lock_init(&fb->lock);
969 	fb->prom_node = node;
970 	fb->prom_parent = parent;
971 	fb->sbdp = sbdp;
972 	if (sbdp)
973 		fb->iospace = sbdp->reg_addrs[0].which_io;
974 
975 	type->fb_type = fbtype;
976 	memset(&fb->emulations, 0xff, sizeof(fb->emulations));
977 	fb->emulations[0] = fbtype;
978 
979 #ifndef __sparc_v9__
980 	disp->screen_base = (unsigned char *)prom_getintdefault(node, "address", 0);
981 #endif
982 
983 	type->fb_height = h = prom_getintdefault(node, "height", 900);
984 	type->fb_width  = w = prom_getintdefault(node, "width", 1152);
985 sizechange:
986 	type->fb_depth  = depth = (fbtype == FBTYPE_SUN2BW) ? 1 : 8;
987 	linebytes = prom_getintdefault(node, "linebytes", w * depth / 8);
988 	type->fb_size   = PAGE_ALIGN((linebytes) * h);
989 
990 	if (defx_margin < 0 || defy_margin < 0) {
991 		for (margin = 0; def_margins[margin].depth; margin++)
992 			if (w == def_margins[margin].xres &&
993 			    h == def_margins[margin].yres &&
994 			    depth == def_margins[margin].depth) {
995 				fb->x_margin = def_margins[margin].x_margin;
996 				fb->y_margin = def_margins[margin].y_margin;
997 				break;
998 			}
999 	} else {
1000 		fb->x_margin = defx_margin;
1001 		fb->y_margin = defy_margin;
1002 	}
1003 	fb->x_margin += ((w - 2*fb->x_margin) & 7) / 2;
1004 	fb->y_margin += ((h - 2*fb->y_margin) & 15) / 2;
1005 
1006 	var->xres_virtual = w;
1007 	var->yres_virtual = h;
1008 	var->xres = w - 2*fb->x_margin;
1009 	var->yres = h - 2*fb->y_margin;
1010 
1011 	var->bits_per_pixel = depth;
1012 	var->height = var->width = -1;
1013 	var->pixclock = 10000;
1014 	var->vmode = FB_VMODE_NONINTERLACED;
1015 	var->red.length = var->green.length = var->blue.length = 8;
1016 
1017 	fix->line_length = linebytes;
1018 	fix->smem_len = type->fb_size;
1019 	fix->type = FB_TYPE_PACKED_PIXELS;
1020 	fix->visual = FB_VISUAL_PSEUDOCOLOR;
1021 
1022 	fb->info.node = -1;
1023 	fb->info.fbops = &sbusfb_ops;
1024 	fb->info.disp = disp;
1025 	strcpy(fb->info.fontname, fontname);
1026 	fb->info.changevar = NULL;
1027 	fb->info.switch_con = &sbusfbcon_switch;
1028 	fb->info.updatevar = &sbusfbcon_updatevar;
1029 	fb->info.blank = &sbusfbcon_blank;
1030 	fb->info.flags = FBINFO_FLAG_DEFAULT;
1031 
1032 	fb->cursor.hwsize.fbx = 32;
1033 	fb->cursor.hwsize.fby = 32;
1034 
1035 	if (depth > 1 && !fb->color_map)
1036 		fb->color_map = kmalloc(256 * 3, GFP_ATOMIC);
1037 
1038 	switch(fbtype) {
1039 #ifdef CONFIG_FB_CREATOR
1040 	case FBTYPE_CREATOR:
1041 		p = creatorfb_init(fb); break;
1042 #endif
1043 #ifdef CONFIG_FB_CGSIX
1044 	case FBTYPE_SUNFAST_COLOR:
1045 		p = cgsixfb_init(fb); break;
1046 #endif
1047 #ifdef CONFIG_FB_CGTHREE
1048 	case FBTYPE_SUN3COLOR:
1049 		p = cgthreefb_init(fb); break;
1050 #endif
1051 #ifdef CONFIG_FB_TCX
1052 	case FBTYPE_TCXCOLOR:
1053 		p = tcxfb_init(fb); break;
1054 #endif
1055 #ifdef CONFIG_FB_LEO
1056 	case FBTYPE_SUNLEO:
1057 		p = leofb_init(fb); break;
1058 #endif
1059 #ifdef CONFIG_FB_BWTWO
1060 	case FBTYPE_SUN2BW:
1061 		p = bwtwofb_init(fb); break;
1062 #endif
1063 #ifdef CONFIG_FB_CGFOURTEEN
1064 	case FBTYPE_MDICOLOR:
1065 		p = cgfourteenfb_init(fb); break;
1066 #endif
1067 #ifdef CONFIG_FB_P9100
1068 	case FBTYPE_P9100COLOR:
1069 		/* Temporary crock. For now we are a cg3 */
1070 		p = p9100fb_init(fb); type->fb_type = FBTYPE_SUN3COLOR; break;
1071 #endif
1072 	}
1073 
1074 	if (!p) {
1075 		if (fb->color_map)
1076 			kfree(fb->color_map);
1077 		kfree(fb);
1078 		return;
1079 	}
1080 
1081 	if (p == SBUSFBINIT_SIZECHANGE)
1082 		goto sizechange;
1083 
1084 	disp->dispsw = &fb->dispsw;
1085 	if (fb->setcursor) {
1086 		fb->dispsw.cursor = sbusfb_cursor;
1087 		if (curblink) {
1088 			fb->cursor.blink_rate = DEFAULT_CURSOR_BLINK_RATE;
1089 			init_timer(&fb->cursor.timer);
1090 			fb->cursor.timer.expires = jiffies + fb->cursor.blink_rate;
1091 			fb->cursor.timer.data = (unsigned long)fb;
1092 			fb->cursor.timer.function = sbusfb_cursor_timer_handler;
1093 			add_timer(&fb->cursor.timer);
1094 		}
1095 	}
1096 	fb->cursor.mode = CURSOR_SHAPE;
1097 	fb->dispsw.set_font = sbusfb_set_font;
1098 	fb->setup = fb->dispsw.setup;
1099 	fb->dispsw.setup = sbusfb_disp_setup;
1100 	fb->dispsw.clear_margins = NULL;
1101 
1102 	disp->var = *var;
1103 	disp->visual = fix->visual;
1104 	disp->type = fix->type;
1105 	disp->type_aux = fix->type_aux;
1106 	disp->line_length = fix->line_length;
1107 
1108 	if (fb->blank)
1109 		disp->can_soft_blank = 1;
1110 
1111 	sbusfb_set_var(var, -1, &fb->info);
1112 
1113 	if (register_framebuffer(&fb->info) < 0) {
1114 		if (fb->color_map)
1115 			kfree(fb->color_map);
1116 		kfree(fb);
1117 		return;
1118 	}
1119 	printk(KERN_INFO "fb%d: %s\n", GET_FB_IDX(fb->info.node), p);
1120 }
1121 
known_card(char * name)1122 static inline int known_card(char *name)
1123 {
1124 	char *p;
1125 	for (p = name; *p && *p != ','; p++);
1126 	if (*p == ',') name = p + 1;
1127 	if (!strcmp(name, "cgsix") || !strcmp(name, "cgthree+"))
1128 		return FBTYPE_SUNFAST_COLOR;
1129 	if (!strcmp(name, "cgthree") || !strcmp(name, "cgRDI"))
1130 		return FBTYPE_SUN3COLOR;
1131 	if (!strcmp(name, "cgfourteen"))
1132 		return FBTYPE_MDICOLOR;
1133 	if (!strcmp(name, "leo"))
1134 		return FBTYPE_SUNLEO;
1135 	if (!strcmp(name, "bwtwo"))
1136 		return FBTYPE_SUN2BW;
1137 	if (!strcmp(name, "tcx"))
1138 		return FBTYPE_TCXCOLOR;
1139 	if (!strcmp(name, "p9100"))
1140 		return FBTYPE_P9100COLOR;
1141 	return FBTYPE_NOTYPE;
1142 }
1143 
1144 #ifdef CONFIG_FB_CREATOR
creator_fb_scan_siblings(int root)1145 static void creator_fb_scan_siblings(int root)
1146 {
1147 	int node, child;
1148 
1149 	child = prom_getchild(root);
1150 	for (node = prom_searchsiblings(child, "SUNW,ffb"); node;
1151 	     node = prom_searchsiblings(prom_getsibling(node), "SUNW,ffb"))
1152 		sbusfb_init_fb(node, root, FBTYPE_CREATOR, NULL);
1153 	for (node = prom_searchsiblings(child, "SUNW,afb"); node;
1154 	     node = prom_searchsiblings(prom_getsibling(node), "SUNW,afb"))
1155 		sbusfb_init_fb(node, root, FBTYPE_CREATOR, NULL);
1156 }
1157 
creator_fb_scan(void)1158 static void creator_fb_scan(void)
1159 {
1160 	int root;
1161 
1162 	creator_fb_scan_siblings(prom_root_node);
1163 
1164 	root = prom_getchild(prom_root_node);
1165 	for (root = prom_searchsiblings(root, "upa"); root;
1166 	     root = prom_searchsiblings(prom_getsibling(root), "upa"))
1167 		creator_fb_scan_siblings(root);
1168 }
1169 #endif
1170 
sbusfb_init(void)1171 int __init sbusfb_init(void)
1172 {
1173 	int type;
1174 	struct sbus_dev *sbdp;
1175 	struct sbus_bus *sbus;
1176 	char prom_name[40];
1177 	extern int con_is_present(void);
1178 
1179 	if (!con_is_present()) return -ENXIO;
1180 
1181 #ifdef CONFIG_FB_CREATOR
1182 	creator_fb_scan();
1183 #endif
1184 #ifdef CONFIG_SUN4
1185 	sbusfb_init_fb(0, 0, FBTYPE_SUN2BW, NULL);
1186 #endif
1187 #if defined(CONFIG_FB_CGFOURTEEN) && !defined(__sparc_v9__)
1188 	{
1189 		int root, node;
1190 		root = prom_getchild(prom_root_node);
1191 		root = prom_searchsiblings(root, "obio");
1192 		if (root &&
1193 		    (node = prom_searchsiblings(prom_getchild(root), "cgfourteen"))) {
1194 			sbusfb_init_fb(node, root, FBTYPE_MDICOLOR, NULL);
1195 		}
1196 	}
1197 #endif
1198 	if (sbus_root == NULL)
1199 		return 0;
1200 	for_all_sbusdev(sbdp, sbus) {
1201 		type = known_card(sbdp->prom_name);
1202 		if (type == FBTYPE_NOTYPE)
1203 			continue;
1204 		if (prom_getproperty(sbdp->prom_node, "emulation",
1205 				     prom_name, sizeof(prom_name)) > 0) {
1206 			type = known_card(prom_name);
1207 			if (type == FBTYPE_NOTYPE)
1208 				type = known_card(sbdp->prom_name);
1209 		}
1210 		sbusfb_init_fb(sbdp->prom_node, sbdp->bus->prom_node, type, sbdp);
1211 	}
1212 	return 0;
1213 }
1214 
1215 MODULE_LICENSE("GPL");
1216