File: /usr/src/linux/drivers/video/g364fb.c
1 /* $Id: g364fb.c,v 1.3 1998/08/28 22:43:00 tsbogend Exp $
2 *
3 * linux/drivers/video/g364fb.c -- Mips Magnum frame buffer device
4 *
5 * (C) 1998 Thomas Bogendoerfer
6 *
7 * This driver is based on tgafb.c
8 *
9 * Copyright (C) 1997 Geert Uytterhoeven
10 * Copyright (C) 1995 Jay Estabrook
11 *
12 * This file is subject to the terms and conditions of the GNU General Public
13 * License. See the file COPYING in the main directory of this archive for
14 * more details.
15 */
16
17 #include <linux/module.h>
18 #include <linux/sched.h>
19 #include <linux/kernel.h>
20 #include <linux/errno.h>
21 #include <linux/string.h>
22 #include <linux/mm.h>
23 #include <linux/tty.h>
24 #include <linux/slab.h>
25 #include <linux/vmalloc.h>
26 #include <linux/delay.h>
27 #include <linux/interrupt.h>
28 #include <linux/fb.h>
29 #include <linux/init.h>
30 #include <linux/pci.h>
31 #include <linux/selection.h>
32 #include <linux/console.h>
33 #include <asm/io.h>
34 #include <asm/jazz.h>
35
36 #include <video/fbcon.h>
37 #include <video/fbcon-cfb8.h>
38
39 /*
40 * Various defines for the G364
41 */
42 #define G364_MEM_BASE 0xe4400000
43 #define G364_PORT_BASE 0xe4000000
44 #define ID_REG 0xe4000000 /* Read only */
45 #define BOOT_REG 0xe4080000
46 #define TIMING_REG 0xe4080108 /* to 0x080170 - DON'T TOUCH! */
47 #define DISPLAY_REG 0xe4080118
48 #define VDISPLAY_REG 0xe4080150
49 #define MASK_REG 0xe4080200
50 #define CTLA_REG 0xe4080300
51 #define CURS_TOGGLE 0x800000
52 #define BIT_PER_PIX 0x700000 /* bits 22 to 20 of Control A */
53 #define DELAY_SAMPLE 0x080000
54 #define PORT_INTER 0x040000
55 #define PIX_PIPE_DEL 0x030000 /* bits 17 and 16 of Control A */
56 #define PIX_PIPE_DEL2 0x008000 /* same as above - don't ask me why */
57 #define TR_CYCLE_TOG 0x004000
58 #define VRAM_ADR_INC 0x003000 /* bits 13 and 12 of Control A */
59 #define BLANK_OFF 0x000800
60 #define FORCE_BLANK 0x000400
61 #define BLK_FUN_SWTCH 0x000200
62 #define BLANK_IO 0x000100
63 #define BLANK_LEVEL 0x000080
64 #define A_VID_FORM 0x000040
65 #define D_SYNC_FORM 0x000020
66 #define FRAME_FLY_PAT 0x000010
67 #define OP_MODE 0x000008
68 #define INTL_STAND 0x000004
69 #define SCRN_FORM 0x000002
70 #define ENABLE_VTG 0x000001
71 #define TOP_REG 0xe4080400
72 #define CURS_PAL_REG 0xe4080508 /* to 0x080518 */
73 #define CHKSUM_REG 0xe4080600 /* to 0x080610 - unused */
74 #define CURS_POS_REG 0xe4080638
75 #define CLR_PAL_REG 0xe4080800 /* to 0x080ff8 */
76 #define CURS_PAT_REG 0xe4081000 /* to 0x081ff8 */
77 #define MON_ID_REG 0xe4100000 /* unused */
78 #define RESET_REG 0xe4180000 /* Write only */
79
80 static int currcon = 0;
81 static struct display disp;
82 static struct fb_info fb_info;
83 static struct { u_char red, green, blue, pad; } palette[256];
84
85 static struct fb_fix_screeninfo fb_fix = { { "G364 8plane", } };
86 static struct fb_var_screeninfo fb_var = { 0, };
87
88
89 /*
90 * Interface used by the world
91 */
92 static int g364fb_get_fix(struct fb_fix_screeninfo *fix, int con,
93 struct fb_info *info);
94 static int g364fb_get_var(struct fb_var_screeninfo *var, int con,
95 struct fb_info *info);
96 static int g364fb_set_var(struct fb_var_screeninfo *var, int con,
97 struct fb_info *info);
98 static int g364fb_pan_display(struct fb_var_screeninfo *var, int con,
99 struct fb_info *info);
100 static int g364fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
101 struct fb_info *info);
102 static int g364fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
103 struct fb_info *info);
104
105
106 /*
107 * Interface to the low level console driver
108 */
109 int g364fb_init(void);
110 static int g364fbcon_switch(int con, struct fb_info *info);
111 static int g364fbcon_updatevar(int con, struct fb_info *info);
112 static void g364fbcon_blank(int blank, struct fb_info *info);
113
114
115 /*
116 * Internal routines
117 */
118 static int g364fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
119 u_int *transp, struct fb_info *info);
120 static int g364fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
121 u_int transp, struct fb_info *info);
122 static void do_install_cmap(int con, struct fb_info *info);
123
124
125 static struct fb_ops g364fb_ops = {
126 owner: THIS_MODULE,
127 fb_get_fix: g364fb_get_fix,
128 fb_get_var: g364fb_get_var,
129 fb_set_var: g364fb_set_var,
130 fb_get_cmap: g364fb_get_cmap,
131 fb_set_cmap: g364fb_set_cmap,
132 fb_pan_display: g364fb_pan_display,
133 };
134
135
136 void fbcon_g364fb_cursor(struct display *p, int mode, int x, int y)
137 {
138 switch (mode) {
139 case CM_ERASE:
140 *(unsigned int *) CTLA_REG |= CURS_TOGGLE;
141 break;
142
143 case CM_MOVE:
144 case CM_DRAW:
145 *(unsigned int *) CTLA_REG &= ~CURS_TOGGLE;
146 *(unsigned int *) CURS_POS_REG = ((x * fontwidth(p)) << 12) | ((y * fontheight(p))-p->var.yoffset);
147 break;
148 }
149 }
150
151
152 static struct display_switch fbcon_g364cfb8 = {
153 setup: fbcon_cfb8_setup,
154 bmove: fbcon_cfb8_bmove,
155 clear: fbcon_cfb8_clear,
156 putc: fbcon_cfb8_putc,
157 putcs: fbcon_cfb8_putcs,
158 revc: fbcon_cfb8_revc,
159 cursor: fbcon_g364fb_cursor,
160 clear_margins: fbcon_cfb8_clear_margins,
161 fontwidthmask: FONTWIDTH(8)
162 };
163
164 /*
165 * Get the Fixed Part of the Display
166 */
167 static int g364fb_get_fix(struct fb_fix_screeninfo *fix, int con,
168 struct fb_info *info)
169 {
170 memcpy(fix, &fb_fix, sizeof(fb_fix));
171 return 0;
172 }
173
174
175 /*
176 * Get the User Defined Part of the Display
177 */
178 static int g364fb_get_var(struct fb_var_screeninfo *var, int con,
179 struct fb_info *info)
180 {
181 memcpy(var, &fb_var, sizeof(fb_var));
182 return 0;
183 }
184
185
186 /*
187 * Set the User Defined Part of the Display
188 */
189 static int g364fb_set_var(struct fb_var_screeninfo *var, int con,
190 struct fb_info *info)
191 {
192 struct display *display;
193 int oldbpp = -1, err;
194
195 if (con >= 0)
196 display = &fb_display[con];
197 else
198 display = &disp; /* used during initialization */
199
200 if (var->xres > fb_var.xres || var->yres > fb_var.yres ||
201 var->xres_virtual > fb_var.xres_virtual ||
202 var->yres_virtual > fb_var.yres_virtual ||
203 var->bits_per_pixel > fb_var.bits_per_pixel ||
204 var->nonstd ||
205 (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
206 return -EINVAL;
207 memcpy(var, &fb_var, sizeof(fb_var));
208
209 if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
210 oldbpp = display->var.bits_per_pixel;
211 display->var = *var;
212 *(unsigned int *)TOP_REG = var->yoffset * var->xres;
213 }
214 if (oldbpp != var->bits_per_pixel) {
215 if ((err = fb_alloc_cmap(&display->cmap, 0, 0)))
216 return err;
217 do_install_cmap(con, info);
218 }
219 return 0;
220 }
221
222
223 /*
224 * Pan or Wrap the Display
225 *
226 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
227 */
228 static int g364fb_pan_display(struct fb_var_screeninfo *var, int con,
229 struct fb_info *info)
230 {
231 if (var->xoffset || var->yoffset+var->yres > var->yres_virtual)
232 return -EINVAL;
233
234 *(unsigned int *)TOP_REG = var->yoffset * var->xres;
235 return 0;
236 }
237
238 /*
239 * Get the Colormap
240 */
241 static int g364fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
242 struct fb_info *info)
243 {
244 if (con == currcon) /* current console? */
245 return fb_get_cmap(cmap, kspc, g364fb_getcolreg, info);
246 else if (fb_display[con].cmap.len) /* non default colormap? */
247 fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
248 else
249 fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
250 cmap, kspc ? 0 : 2);
251 return 0;
252 }
253
254 /*
255 * Set the Colormap
256 */
257 static int g364fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
258 struct fb_info *info)
259 {
260 int err;
261
262 if (!fb_display[con].cmap.len) { /* no colormap allocated? */
263 if ((err = fb_alloc_cmap(&fb_display[con].cmap,
264 1<<fb_display[con].var.bits_per_pixel, 0)))
265 return err;
266 }
267 if (con == currcon) { /* current console? */
268 return fb_set_cmap(cmap, kspc, g364fb_setcolreg, info);
269 } else
270 fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
271 return 0;
272 }
273
274
275 /*
276 * Initialisation
277 */
278 int __init g364fb_init(void)
279 {
280 int i,j;
281 volatile unsigned int *pal_ptr = (volatile unsigned int *) CLR_PAL_REG;
282 volatile unsigned int *curs_pal_ptr = (volatile unsigned int *) CURS_PAL_REG;
283 unsigned int xres, yres;
284 int mem;
285
286 /* TBD: G364 detection */
287
288 /* get the resolution set by ARC console */
289 *(volatile unsigned int *)CTLA_REG &= ~ENABLE_VTG;
290 xres = (*((volatile unsigned int*)DISPLAY_REG) & 0x00ffffff) * 4;
291 yres = (*((volatile unsigned int*)VDISPLAY_REG) & 0x00ffffff) / 2;
292 *(volatile unsigned int *)CTLA_REG |= ENABLE_VTG;
293
294 /* initialise color palette */
295 for (i = 0; i < 16; i++) {
296 j = color_table[i];
297 palette[i].red=default_red[j];
298 palette[i].green=default_grn[j];
299 palette[i].blue=default_blu[j];
300 pal_ptr[i << 1] = (palette[i].red << 16) | (palette[i].green << 8) | palette[i].blue;
301 }
302
303 /* setup cursor */
304 curs_pal_ptr[0] |= 0x00ffffff;
305 curs_pal_ptr[2] |= 0x00ffffff;
306 curs_pal_ptr[4] |= 0x00ffffff;
307
308 /*
309 * first set the whole cursor to transparent
310 */
311 for (i = 0; i < 512; i++)
312 *(unsigned short *)(CURS_PAT_REG+i*8) = 0;
313
314 /*
315 * switch the last two lines to cursor palette 3
316 * we assume here, that FONTSIZE_X is 8
317 */
318 *(unsigned short *)(CURS_PAT_REG + 14*64) = 0xffff;
319 *(unsigned short *)(CURS_PAT_REG + 15*64) = 0xffff;
320
321 fb_var.bits_per_pixel = 8;
322 fb_var.xres = fb_var.xres_virtual = xres;
323 fb_var.yres = yres;
324
325 fb_fix.line_length = (xres / 8) * fb_var.bits_per_pixel;
326 fb_fix.smem_start = 0x40000000; /* physical address */
327 /* get size of video memory; this is special for the JAZZ hardware */
328 mem = (r4030_read_reg32(JAZZ_R4030_CONFIG) >> 8) & 3;
329 fb_fix.smem_len = (1 << (mem*2)) * 512 * 1024;
330 fb_fix.type = FB_TYPE_PACKED_PIXELS;
331 fb_fix.type_aux = 0;
332 fb_fix.visual = FB_VISUAL_PSEUDOCOLOR;
333 fb_fix.xpanstep = 0;
334 fb_fix.ypanstep = 1;
335 fb_fix.ywrapstep = 0;
336 fb_fix.mmio_start = 0;
337 fb_fix.mmio_len = 0;
338 fb_fix.accel = FB_ACCEL_NONE;
339
340 fb_var.yres_virtual = fb_fix.smem_len / xres;
341 fb_var.xoffset = fb_var.yoffset = 0;
342 fb_var.grayscale = 0;
343
344 fb_var.red.offset = 0;
345 fb_var.green.offset = 0;
346 fb_var.blue.offset = 0;
347
348 fb_var.red.length = fb_var.green.length = fb_var.blue.length = 8;
349 fb_var.red.msb_right = fb_var.green.msb_right = fb_var.blue.msb_right = 0;
350 fb_var.transp.offset = fb_var.transp.length = fb_var.transp.msb_right = 0;
351 fb_var.nonstd = 0;
352 fb_var.activate = 0;
353 fb_var.height = fb_var.width = -1;
354 fb_var.accel_flags = 0;
355 fb_var.pixclock = 39722;
356 fb_var.left_margin = 40;
357 fb_var.right_margin = 24;
358 fb_var.upper_margin = 32;
359 fb_var.lower_margin = 11;
360 fb_var.hsync_len = 96;
361 fb_var.vsync_len = 2;
362 fb_var.sync = 0;
363 fb_var.vmode = FB_VMODE_NONINTERLACED;
364
365 disp.var = fb_var;
366 disp.cmap.start = 0;
367 disp.cmap.len = 0;
368 disp.cmap.red = disp.cmap.green = disp.cmap.blue = disp.cmap.transp = NULL;
369 disp.screen_base = (char *)G364_MEM_BASE; /* virtual kernel address */
370 disp.visual = fb_fix.visual;
371 disp.type = fb_fix.type;
372 disp.type_aux = fb_fix.type_aux;
373 disp.ypanstep = fb_fix.ypanstep;
374 disp.ywrapstep = fb_fix.ywrapstep;
375 disp.line_length = fb_fix.line_length;
376 disp.can_soft_blank = 1;
377 disp.inverse = 0;
378 disp.dispsw = &fbcon_g364cfb8;
379
380 strcpy(fb_info.modename, fb_fix.id);
381 fb_info.node = -1;
382 fb_info.fbops = &g364fb_ops;
383 fb_info.disp = &disp;
384 fb_info.fontname[0] = '\0';
385 fb_info.changevar = NULL;
386 fb_info.switch_con = &g364fbcon_switch;
387 fb_info.updatevar = &g364fbcon_updatevar;
388 fb_info.blank = &g364fbcon_blank;
389 fb_info.flags = FBINFO_FLAG_DEFAULT;
390
391 g364fb_set_var(&fb_var, -1, &fb_info);
392
393 if (register_framebuffer(&fb_info) < 0)
394 return -EINVAL;
395
396 printk("fb%d: %s frame buffer device\n", GET_FB_IDX(fb_info.node),
397 fb_fix.id);
398 return 0;
399 }
400
401
402 static int g364fbcon_switch(int con, struct fb_info *info)
403 {
404 /* Do we have to save the colormap? */
405 if (fb_display[currcon].cmap.len)
406 fb_get_cmap(&fb_display[currcon].cmap, 1, g364fb_getcolreg, info);
407
408 currcon = con;
409 /* Install new colormap */
410 do_install_cmap(con, info);
411 g364fbcon_updatevar(con, info);
412 return 0;
413 }
414
415 /*
416 * Update the `var' structure (called by fbcon.c)
417 */
418 static int g364fbcon_updatevar(int con, struct fb_info *info)
419 {
420 if (con == currcon) {
421 struct fb_var_screeninfo *var = &fb_display[currcon].var;
422
423 /* hardware scrolling */
424 *(unsigned int *)TOP_REG = var->yoffset * var->xres;
425 }
426 return 0;
427 }
428
429 /*
430 * Blank the display.
431 */
432 static void g364fbcon_blank(int blank, struct fb_info *info)
433 {
434 if (blank)
435 *(unsigned int *) CTLA_REG |= FORCE_BLANK;
436 else
437 *(unsigned int *) CTLA_REG &= ~FORCE_BLANK;
438 }
439
440 /*
441 * Read a single color register and split it into
442 * colors/transparent. Return != 0 for invalid regno.
443 */
444 static int g364fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
445 u_int *transp, struct fb_info *info)
446 {
447 if (regno > 255)
448 return 1;
449 *red = (palette[regno].red << 8) | palette[regno].red;
450 *green = (palette[regno].green << 8) | palette[regno].green;
451 *blue = (palette[regno].blue << 8) | palette[regno].blue;
452 *transp = 0;
453 return 0;
454 }
455
456 /*
457 * Set a single color register. Return != 0 for invalid regno.
458 */
459 static int g364fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
460 u_int transp, struct fb_info *info)
461 {
462 volatile unsigned int *ptr = (volatile unsigned int *) CLR_PAL_REG;
463
464 if (regno > 255)
465 return 1;
466
467 red >>= 8;
468 green >>= 8;
469 blue >>=8;
470 palette[regno].red = red;
471 palette[regno].green = green;
472 palette[regno].blue = blue;
473
474 ptr[regno << 1] = (red << 16) | (green << 8) | blue;
475
476 return 0;
477 }
478
479
480 static void do_install_cmap(int con, struct fb_info *info)
481 {
482 if (con != currcon)
483 return;
484 if (fb_display[con].cmap.len)
485 fb_set_cmap(&fb_display[con].cmap, 1, g364fb_setcolreg, info);
486 else
487 fb_set_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel), 1,
488 g364fb_setcolreg, info);
489 }
490
491 MODULE_LICENSE("GPL");
492