?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] iseries_veth: Replace lock-protected atomic with an ordinary variable
[usb.git] / drivers / video / sun3fb.c
blob9b36b9df535f2cdcd45207f63612631258628ed3
1 /*
2 * linux/drivers/video/sun3fb.c -- Frame buffer driver for Sun3
3 *
4 * (C) 1998 Thomas Bogendoerfer
5 *
6 * This driver is bases on sbusfb.c, which is
7 *
8 * Copyright (C) 1998 Jakub Jelinek
9 *
10 * This driver is partly based on the Open Firmware console driver
11 *
12 * Copyright (C) 1997 Geert Uytterhoeven
13 *
14 * and SPARC console subsystem
15 *
16 * Copyright (C) 1995 Peter Zaitcev (zaitcev@yahoo.com)
17 * Copyright (C) 1995-1997 David S. Miller (davem@caip.rutgers.edu)
18 * Copyright (C) 1995-1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
19 * Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
20 * Copyright (C) 1996-1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
21 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
22 *
23 * This file is subject to the terms and conditions of the GNU General Public
24 * License. See the file COPYING in the main directory of this archive for
25 * more details.
26 */
27
28 #include <linux/config.h>
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/errno.h>
32 #include <linux/string.h>
33 #include <linux/mm.h>
34 #include <linux/tty.h>
35 #include <linux/slab.h>
36 #include <linux/vmalloc.h>
37 #include <linux/delay.h>
38 #include <linux/interrupt.h>
39 #include <linux/fb.h>
40 #include <linux/selection.h>
41 #include <linux/init.h>
42 #include <linux/console.h>
43 #include <linux/kd.h>
44 #include <linux/vt_kern.h>
45
46 #include <asm/uaccess.h>
47 #include <asm/pgtable.h> /* io_remap_page_range() */
48
49 #ifdef CONFIG_SUN3
50 #include <asm/oplib.h>
51 #include <asm/machines.h>
52 #include <asm/idprom.h>
53
54 #define CGFOUR_OBMEM_ADDR 0x1f300000
55 #define BWTWO_OBMEM_ADDR 0x1f000000
56 #define BWTWO_OBMEM50_ADDR 0x00100000
57
58 #endif
59 #ifdef CONFIG_SUN3X
60 #include <asm/sun3x.h>
61 #endif
62 #include <video/sbusfb.h>
63
64 #define DEFAULT_CURSOR_BLINK_RATE (2*HZ/5)
65
66 #define CURSOR_SHAPE 1
67 #define CURSOR_BLINK 2
68
69 #define mymemset(x,y) memset(x,0,y)
70
71 /*
72 * Interface used by the world
73 */
74
75 int sun3fb_init(void);
76 void sun3fb_setup(char *options);
77
78 static char fontname[40] __initdata = { 0 };
79 static int curblink __initdata = 1;
80
81 static int sun3fb_get_fix(struct fb_fix_screeninfo *fix, int con,
82 struct fb_info *info);
83 static int sun3fb_get_var(struct fb_var_screeninfo *var, int con,
84 struct fb_info *info);
85 static int sun3fb_set_var(struct fb_var_screeninfo *var, int con,
86 struct fb_info *info);
87 static int sun3fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
88 struct fb_info *info);
89 static int sun3fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
90 struct fb_info *info);
91 static int sun3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
92 u_int transp, struct fb_info *info);
93 static int sun3fb_blank(int blank, struct fb_info *info);
94 static void sun3fb_cursor(struct display *p, int mode, int x, int y);
95 static void sun3fb_clear_margin(struct display *p, int s);
96
97 /*
98 * Interface to the low level console driver
99 */
100
101 static int sun3fbcon_switch(int con, struct fb_info *info);
102 static int sun3fbcon_updatevar(int con, struct fb_info *info);
103
104 /*
105 * Internal routines
106 */
107
108 static int sun3fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
109 u_int *transp, struct fb_info *info);
110
111 static struct fb_ops sun3fb_ops = {
112 .owner = THIS_MODULE,
113 .fb_get_fix = sun3fb_get_fix,
114 .fb_get_var = sun3fb_get_var,
115 .fb_set_var = sun3fb_set_var,
116 .fb_get_cmap = sun3fb_get_cmap,
117 .fb_set_cmap = sun3fb_set_cmap,
118 .fb_setcolreg = sun3fb_setcolreg,
119 .fb_blank = sun3fb_blank,
120 };
121
122 static void sun3fb_clear_margin(struct display *p, int s)
123 {
124 struct fb_info_sbusfb *fb = sbusfbinfod(p);
125
126 return;
127
128 if (fb->switch_from_graph)
129 (*fb->switch_from_graph)(fb);
130 if (fb->fill) {
131 unsigned short rects [16];
132
133 rects [0] = 0;
134 rects [1] = 0;
135 rects [2] = fb->var.xres_virtual;
136 rects [3] = fb->y_margin;
137 rects [4] = 0;
138 rects [5] = fb->y_margin;
139 rects [6] = fb->x_margin;
140 rects [7] = fb->var.yres_virtual;
141 rects [8] = fb->var.xres_virtual - fb->x_margin;
142 rects [9] = fb->y_margin;
143 rects [10] = fb->var.xres_virtual;
144 rects [11] = fb->var.yres_virtual;
145 rects [12] = fb->x_margin;
146 rects [13] = fb->var.yres_virtual - fb->y_margin;
147 rects [14] = fb->var.xres_virtual - fb->x_margin;
148 rects [15] = fb->var.yres_virtual;
149 (*fb->fill)(fb, p, s, 4, rects);
150 } else {
151 unsigned char *fb_base = fb->info.screen_base, *q;
152 int skip_bytes = fb->y_margin * fb->var.xres_virtual;
153 int scr_size = fb->var.xres_virtual * fb->var.yres_virtual;
154 int h, he, incr, size;
155
156 he = fb->var.yres;
157 if (fb->var.bits_per_pixel == 1) {
158 fb_base -= (skip_bytes + fb->x_margin) / 8;
159 skip_bytes /= 8;
160 scr_size /= 8;
161 mymemset (fb_base, skip_bytes - fb->x_margin / 8);
162 mymemset (fb_base + scr_size - skip_bytes + fb->x_margin / 8, skip_bytes - fb->x_margin / 8);
163 incr = fb->var.xres_virtual / 8;
164 size = fb->x_margin / 8 * 2;
165 for (q = fb_base + skip_bytes - fb->x_margin / 8, h = 0;
166 h <= he; q += incr, h++)
167 mymemset (q, size);
168 } else {
169 fb_base -= (skip_bytes + fb->x_margin);
170 memset (fb_base, attr_bgcol(p,s), skip_bytes - fb->x_margin);
171 memset (fb_base + scr_size - skip_bytes + fb->x_margin, attr_bgcol(p,s), skip_bytes - fb->x_margin);
172 incr = fb->var.xres_virtual;
173 size = fb->x_margin * 2;
174 for (q = fb_base + skip_bytes - fb->x_margin, h = 0;
175 h <= he; q += incr, h++)
176 memset (q, attr_bgcol(p,s), size);
177 }
178 }
179 }
180
181 static void sun3fb_disp_setup(struct display *p)
182 {
183 struct fb_info_sbusfb *fb = sbusfbinfod(p);
184
185 if (fb->setup)
186 fb->setup(p);
187 sun3fb_clear_margin(p, 0);
188 }
189
190 /*
191 * Get the Fixed Part of the Display
192 */
193
194 static int sun3fb_get_fix(struct fb_fix_screeninfo *fix, int con,
195 struct fb_info *info)
196 {
197 struct fb_info_sbusfb *fb = sbusfbinfo(info);
198
199 memcpy(fix, &fb->fix, sizeof(struct fb_fix_screeninfo));
200 return 0;
201 }
202
203 /*
204 * Get the User Defined Part of the Display
205 */
206
207 static int sun3fb_get_var(struct fb_var_screeninfo *var, int con,
208 struct fb_info *info)
209 {
210 struct fb_info_sbusfb *fb = sbusfbinfo(info);
211
212 memcpy(var, &fb->var, sizeof(struct fb_var_screeninfo));
213 return 0;
214 }
215
216 /*
217 * Set the User Defined Part of the Display
218 */
219
220 static int sun3fb_set_var(struct fb_var_screeninfo *var, int con,
221 struct fb_info *info)
222 {
223 struct fb_info_sbusfb *fb = sbusfbinfo(info);
224
225 if (var->xres > fb->var.xres || var->yres > fb->var.yres ||
226 var->xres_virtual > fb->var.xres_virtual ||
227 var->yres_virtual > fb->var.yres_virtual ||
228 var->bits_per_pixel != fb->var.bits_per_pixel ||
229 var->nonstd ||
230 (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
231 return -EINVAL;
232 memcpy(var, &fb->var, sizeof(struct fb_var_screeninfo));
233 return 0;
234 }
235
236 /*
237 * Hardware cursor
238 */
239
240 static unsigned char hw_cursor_cmap[2] = { 0, 0xff };
241
242 static void
243 sun3fb_cursor_timer_handler(unsigned long dev_addr)
244 {
245 struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)dev_addr;
246
247 if (!fb->setcursor) return;
248
249 if (fb->cursor.mode & CURSOR_BLINK) {
250 fb->cursor.enable ^= 1;
251 fb->setcursor(fb);
252 }
253
254 fb->cursor.timer.expires = jiffies + fb->cursor.blink_rate;
255 add_timer(&fb->cursor.timer);
256 }
257
258 static void sun3fb_cursor(struct display *p, int mode, int x, int y)
259 {
260 struct fb_info_sbusfb *fb = sbusfbinfod(p);
261
262 switch (mode) {
263 case CM_ERASE:
264 fb->cursor.mode &= ~CURSOR_BLINK;
265 fb->cursor.enable = 0;
266 (*fb->setcursor)(fb);
267 break;
268
269 case CM_MOVE:
270 case CM_DRAW:
271 if (fb->cursor.mode & CURSOR_SHAPE) {
272 fb->cursor.size.fbx = fontwidth(p);
273 fb->cursor.size.fby = fontheight(p);
274 fb->cursor.chot.fbx = 0;
275 fb->cursor.chot.fby = 0;
276 fb->cursor.enable = 1;
277 memset (fb->cursor.bits, 0, sizeof (fb->cursor.bits));
278 fb->cursor.bits[0][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
279 fb->cursor.bits[1][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
280 fb->cursor.bits[0][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
281 fb->cursor.bits[1][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
282 (*fb->setcursormap) (fb, hw_cursor_cmap, hw_cursor_cmap, hw_cursor_cmap);
283 (*fb->setcurshape) (fb);
284 }
285 fb->cursor.mode = CURSOR_BLINK;
286 if (fontwidthlog(p))
287 fb->cursor.cpos.fbx = (x << fontwidthlog(p)) + fb->x_margin;
288 else
289 fb->cursor.cpos.fbx = (x * fontwidth(p)) + fb->x_margin;
290 if (fontheightlog(p))
291 fb->cursor.cpos.fby = (y << fontheightlog(p)) + fb->y_margin;
292 else
293 fb->cursor.cpos.fby = (y * fontheight(p)) + fb->y_margin;
294 (*fb->setcursor)(fb);
295 break;
296 }
297 }
298
299 /*
300 * Get the Colormap
301 */
302
303 static int sun3fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
304 struct fb_info *info)
305 {
306 if (con == info->currcon) /* current console? */
307 return fb_get_cmap(cmap, kspc, sun3fb_getcolreg, info);
308 else if (fb_display[con].cmap.len) /* non default colormap? */
309 fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
310 else
311 fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel), cmap, kspc ? 0 : 2);
312 return 0;
313 }
314
315 /*
316 * Set the Colormap
317 */
318
319 static int sun3fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
320 struct fb_info *info)
321 {
322 int err;
323
324 if (!fb_display[con].cmap.len) { /* no colormap allocated? */
325 if ((err = fb_alloc_cmap(&fb_display[con].cmap, 1<<fb_display[con].var.bits_per_pixel, 0)))
326 return err;
327 }
328 if (con == info->currcon) { /* current console? */
329 err = fb_set_cmap(cmap, kspc, info);
330 if (!err) {
331 struct fb_info_sbusfb *fb = sbusfbinfo(info);
332
333 if (fb->loadcmap)
334 (*fb->loadcmap)(fb, &fb_display[con], cmap->start, cmap->len);
335 }
336 return err;
337 } else
338 fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
339 return 0;
340 }
341
342 /*
343 * Setup: parse used options
344 */
345
346 void __init sun3fb_setup(char *options)
347 {
348 char *p;
349
350 for (p = options;;) {
351 if (!strncmp(p, "font=", 5)) {
352 int i;
353
354 for (i = 0; i < sizeof(fontname) - 1; i++)
355 if (p[i+5] == ' ' || !p[i+5])
356 break;
357 memcpy(fontname, p+5, i);
358 fontname[i] = 0;
359 } else if (!strncmp(p, "noblink", 7))
360 curblink = 0;
361 while (*p && *p != ' ' && *p != ',') p++;
362 if (*p != ',') break;
363 p++;
364 }
365
366 return;
367 }
368
369 static int sun3fbcon_switch(int con, struct fb_info *info)
370 {
371 int x_margin, y_margin;
372 struct fb_info_sbusfb *fb = sbusfbinfo(info);
373 int lastconsole;
374
375 /* Do we have to save the colormap? */
376 if (fb_display[info->currcon].cmap.len)
377 fb_get_cmap(&fb_display[info->currcon].cmap, 1, sun3fb_getcolreg, info);
378
379 if (info->display_fg) {
380 lastconsole = info->display_fg->vc_num;
381 if (lastconsole != con &&
382 (fontwidth(&fb_display[lastconsole]) != fontwidth(&fb_display[con]) ||
383 fontheight(&fb_display[lastconsole]) != fontheight(&fb_display[con])))
384 fb->cursor.mode |= CURSOR_SHAPE;
385 }
386 x_margin = (fb_display[con].var.xres_virtual - fb_display[con].var.xres) / 2;
387 y_margin = (fb_display[con].var.yres_virtual - fb_display[con].var.yres) / 2;
388 if (fb->margins)
389 fb->margins(fb, &fb_display[con], x_margin, y_margin);
390 if (fb->graphmode || fb->x_margin != x_margin || fb->y_margin != y_margin) {
391 fb->x_margin = x_margin; fb->y_margin = y_margin;
392 sun3fb_clear_margin(&fb_display[con], 0);
393 }
394 info->currcon = con;
395 /* Install new colormap */
396 do_install_cmap(con, info);
397 return 0;
398 }
399
400 /*
401 * Update the `var' structure (called by fbcon.c)
402 */
403
404 static int sun3fbcon_updatevar(int con, struct fb_info *info)
405 {
406 /* Nothing */
407 return 0;
408 }
409
410 /*
411 * Blank the display.
412 */
413
414 static int sun3fb_blank(int blank, struct fb_info *info)
415 {
416 struct fb_info_sbusfb *fb = sbusfbinfo(info);
417
418 if (blank && fb->blank)
419 return fb->blank(fb);
420 else if (!blank && fb->unblank)
421 return fb->unblank(fb);
422 return 0;
423 }
424
425 /*
426 * Read a single color register and split it into
427 * colors/transparent. Return != 0 for invalid regno.
428 */
429
430 static int sun3fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
431 u_int *transp, struct fb_info *info)
432 {
433 struct fb_info_sbusfb *fb = sbusfbinfo(info);
434
435 if (!fb->color_map || regno > 255)
436 return 1;
437 *red = (fb->color_map CM(regno, 0)<<8) | fb->color_map CM(regno, 0);
438 *green = (fb->color_map CM(regno, 1)<<8) | fb->color_map CM(regno, 1);
439 *blue = (fb->color_map CM(regno, 2)<<8) | fb->color_map CM(regno, 2);
440 *transp = 0;
441 return 0;
442 }
443
444
445 /*
446 * Set a single color register. The values supplied are already
447 * rounded down to the hardware's capabilities (according to the
448 * entries in the var structure). Return != 0 for invalid regno.
449 */
450
451 static int sun3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
452 u_int transp, struct fb_info *info)
453 {
454 struct fb_info_sbusfb *fb = sbusfbinfo(info);
455
456 if (!fb->color_map || regno > 255)
457 return 1;
458 red >>= 8;
459 green >>= 8;
460 blue >>= 8;
461 fb->color_map CM(regno, 0) = red;
462 fb->color_map CM(regno, 1) = green;
463 fb->color_map CM(regno, 2) = blue;
464 return 0;
465 }
466
467 static int sun3fb_set_font(struct display *p, int width, int height)
468 {
469 int w = p->var.xres_virtual, h = p->var.yres_virtual;
470 int depth = p->var.bits_per_pixel;
471 struct fb_info_sbusfb *fb = sbusfbinfod(p);
472 int x_margin, y_margin;
473
474 if (depth > 8) depth = 8;
475 x_margin = (w % width) / 2;
476 y_margin = (h % height) / 2;
477
478 p->var.xres = w - 2*x_margin;
479 p->var.yres = h - 2*y_margin;
480
481 fb->cursor.mode |= CURSOR_SHAPE;
482
483 if (fb->margins)
484 fb->margins(fb, p, x_margin, y_margin);
485 if (fb->x_margin != x_margin || fb->y_margin != y_margin) {
486 fb->x_margin = x_margin; fb->y_margin = y_margin;
487 sun3fb_clear_margin(p, 0);
488 }
489
490 return 1;
491 }
492
493 void sun3fb_palette(int enter)
494 {
495 int i;
496 struct display *p;
497
498 for (i = 0; i < MAX_NR_CONSOLES; i++) {
499 p = &fb_display[i];
500 if (p->dispsw && p->dispsw->setup == sun3fb_disp_setup &&
501 p->fb_info->display_fg &&
502 p->fb_info->display_fg->vc_num == i) {
503 struct fb_info_sbusfb *fb = sbusfbinfod(p);
504
505 if (fb->restore_palette) {
506 if (enter)
507 fb->restore_palette(fb);
508 else if (vc_cons[i].d->vc_mode != KD_GRAPHICS)
509 vc_cons[i].d->vc_sw->con_set_palette(vc_cons[i].d, color_table);
510 }
511 }
512 }
513 }
514
515 /*
516 * Initialisation
517 */
518 static int __init sun3fb_init_fb(int fbtype, unsigned long addr)
519 {
520 static struct sbus_dev sdb;
521 struct fb_fix_screeninfo *fix;
522 struct fb_var_screeninfo *var;
523 struct display *disp;
524 struct fb_info_sbusfb *fb;
525 struct fbtype *type;
526 int linebytes, w, h, depth;
527 char *p = NULL;
528
529 fb = kmalloc(sizeof(struct fb_info_sbusfb), GFP_ATOMIC);
530 if (!fb)
531 return -ENOMEM;
532
533 memset(fb, 0, sizeof(struct fb_info_sbusfb));
534 fix = &fb->fix;
535 var = &fb->var;
536 disp = &fb->disp;
537 type = &fb->type;
538
539 sdb.reg_addrs[0].phys_addr = addr;
540 fb->sbdp = &sdb;
541
542 type->fb_type = fbtype;
543
544 type->fb_height = h = 900;
545 type->fb_width = w = 1152;
546 sizechange:
547 type->fb_depth = depth = (fbtype == FBTYPE_SUN2BW) ? 1 : 8;
548 linebytes = w * depth / 8;
549 type->fb_size = PAGE_ALIGN((linebytes) * h);
550 /*
551 fb->x_margin = (w & 7) / 2;
552 fb->y_margin = (h & 15) / 2;
553 */
554 fb->x_margin = fb->y_margin = 0;
555
556 var->xres_virtual = w;
557 var->yres_virtual = h;
558 var->xres = w - 2*fb->x_margin;
559 var->yres = h - 2*fb->y_margin;
560
561 var->bits_per_pixel = depth;
562 var->height = var->width = -1;
563 var->pixclock = 10000;
564 var->vmode = FB_VMODE_NONINTERLACED;
565 var->red.length = var->green.length = var->blue.length = 8;
566
567 fix->line_length = linebytes;
568 fix->smem_len = type->fb_size;
569 fix->type = FB_TYPE_PACKED_PIXELS;
570 fix->visual = FB_VISUAL_PSEUDOCOLOR;
571
572 fb->info.fbops = &sun3fb_ops;
573 fb->info.disp = disp;
574 fb->info.currcon = -1;
575 strcpy(fb->info.fontname, fontname);
576 fb->info.changevar = NULL;
577 fb->info.switch_con = &sun3fbcon_switch;
578 fb->info.updatevar = &sun3fbcon_updatevar;
579 fb->info.flags = FBINFO_FLAG_DEFAULT;
580
581 fb->cursor.hwsize.fbx = 32;
582 fb->cursor.hwsize.fby = 32;
583
584 if (depth > 1 && !fb->color_map) {
585 if((fb->color_map = kmalloc(256 * 3, GFP_ATOMIC))==NULL)
586 return -ENOMEM;
587 }
588
589 switch(fbtype) {
590 #ifdef CONFIG_FB_CGSIX
591 case FBTYPE_SUNFAST_COLOR:
592 p = cgsixfb_init(fb); break;
593 #endif
594 #ifdef CONFIG_FB_BWTWO
595 case FBTYPE_SUN2BW:
596 p = bwtwofb_init(fb); break;
597 #endif
598 #ifdef CONFIG_FB_CGTHREE
599 case FBTYPE_SUN4COLOR:
600 case FBTYPE_SUN3COLOR:
601 type->fb_size = 0x100000;
602 p = cgthreefb_init(fb); break;
603 #endif
604 }
605 fix->smem_start = (unsigned long)fb->info.screen_base; // FIXME
606
607 if (!p) {
608 kfree(fb);
609 return -ENODEV;
610 }
611
612 if (p == SBUSFBINIT_SIZECHANGE)
613 goto sizechange;
614
615 disp->dispsw = &fb->dispsw;
616 if (fb->setcursor) {
617 fb->dispsw.cursor = sun3fb_cursor;
618 if (curblink) {
619 fb->cursor.blink_rate = DEFAULT_CURSOR_BLINK_RATE;
620 init_timer(&fb->cursor.timer);
621 fb->cursor.timer.expires = jiffies + fb->cursor.blink_rate;
622 fb->cursor.timer.data = (unsigned long)fb;
623 fb->cursor.timer.function = sun3fb_cursor_timer_handler;
624 add_timer(&fb->cursor.timer);
625 }
626 }
627 fb->cursor.mode = CURSOR_SHAPE;
628 fb->dispsw.set_font = sun3fb_set_font;
629 fb->setup = fb->dispsw.setup;
630 fb->dispsw.setup = sun3fb_disp_setup;
631 fb->dispsw.clear_margins = NULL;
632
633 disp->var = *var;
634 disp->visual = fix->visual;
635 disp->type = fix->type;
636 disp->type_aux = fix->type_aux;
637 disp->line_length = fix->line_length;
638
639 if (fb->blank)
640 disp->can_soft_blank = 1;
641
642 sun3fb_set_var(var, -1, &fb->info);
643
644 if (register_framebuffer(&fb->info) < 0) {
645 kfree(fb);
646 return -EINVAL;
647 }
648 printk("fb%d: %s\n", fb->info.node, p);
649
650 return 0;
651 }
652
653
654 int __init sun3fb_init(void)
655 {
656 extern int con_is_present(void);
657 unsigned long addr;
658 char p4id;
659
660 if (!con_is_present()) return -ENODEV;
661 #ifdef CONFIG_SUN3
662 switch(*(romvec->pv_fbtype))
663 {
664 case FBTYPE_SUN2BW:
665 addr = 0xfe20000;
666 return sun3fb_init_fb(FBTYPE_SUN2BW, addr);
667 case FBTYPE_SUN3COLOR:
668 case FBTYPE_SUN4COLOR:
669 if(idprom->id_machtype != (SM_SUN3|SM_3_60)) {
670 printk("sun3fb: cgthree/four only supported on 3/60\n");
671 return -ENODEV;
672 }
673
674 addr = CGFOUR_OBMEM_ADDR;
675 return sun3fb_init_fb(*(romvec->pv_fbtype), addr);
676 default:
677 printk("sun3fb: unsupported framebuffer\n");
678 return -ENODEV;
679 }
680 #else
681 addr = SUN3X_VIDEO_BASE;
682 p4id = *(char *)SUN3X_VIDEO_P4ID;
683
684 p4id = (p4id == 0x45) ? p4id : (p4id & 0xf0);
685 switch (p4id) {
686 case 0x00:
687 return sun3fb_init_fb(FBTYPE_SUN2BW, addr);
688 #if 0 /* not yet */
689 case 0x40:
690 return sun3fb_init_fb(FBTYPE_SUN4COLOR, addr);
691 break;
692 case 0x45:
693 return sun3fb_init_fb(FBTYPE_SUN8COLOR, addr);
694 break;
695 #endif
696 case 0x60:
697 return sun3fb_init_fb(FBTYPE_SUNFAST_COLOR, addr);
698 }
699 #endif
700
701 return -ENODEV;
702 }
703
704 MODULE_LICENSE("GPL");
USB Experimental Work